OCC Main Page | ModelingAlgorithms | Toolkits | Packages | Class Hierarchy | Data Structures | File List | Data Fields | Globals

OpenCASCADE Data Structures

Here are the data structures with brief descriptions:
AppBlend_ApproxBspline approximation of a surface.
AppBlend_SequenceNodeOfSequenceOfArray1OfPnt2d
AppBlend_SequenceOfArray1OfPnt2d
ApproxInt_SvSurfaces
BisectorThis package provides the bisecting line between two
geometric elements.
Bisector_BisecBisec provides the bisecting line between two elements
This line is trimed by a point

and it's contained in the domain
defined by the two vectors <v1>, <v2> and <sense>.

Definition of the domain:
if <sense> is true the bisecting line is contained in the sector
defined by <-V1> and <-V2> in the sense indirect.
if <sense> is false the bisecting line is contained in the sector
defined by <-V1> and <-V2> in the sense direct.

Bisector_BisecAna
Bisector_BisecCCConstruct the bisector between two curves.
The curves can intersect only in their extremities.
Bisector_BisecPCProvides 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_FunctionHH(v) = (T1 .P2(v) - P1) * ||T(v)|| -
2 2
(T(v).P2(v) - P1) * ||T1||
Bisector_FunctionInter2 2
F(u) = (PC(u) - PBis1(u)) + (PC(u) - PBis2(u))
Bisector_InterIntersection between two <bisec> from Bisector.
Bisector_PointOnBis
Bisector_PolyBisPolygon of PointOnBis
BiTgte_Blend
BiTgte_CurveOnEdge
BiTgte_CurveOnVertex
BiTgte_DataMapIteratorOfDataMapOfShapeBox
BiTgte_DataMapNodeOfDataMapOfShapeBox
BiTgte_DataMapOfShapeBox
BiTgte_HCurveOnEdge
BiTgte_HCurveOnVertex
Blend_AppFunctionDeferred 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_CSFunctionDeferred 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_CurvPointFuncInvDeferred 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_FuncInvDeferred 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_FunctionDeferred 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_RstRstFunctionDeferred 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_SurfCurvFuncInvDeferred 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_SurfPointFuncInvDeferred 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_SurfRstFunctionDeferred 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.
BlendFuncThis package provides a set of generic functions, that can
instantiated to compute blendings between two surfaces
(Constant radius, Evolutive radius, Ruled surface).
BlendFunc_TensorUsed to store the "gradient of gradient"
BooleanOperations_AncestorsAndSuccessorsAll 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_AncestorsSeqAndSuccessorsSeqProvide 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_ExplorerExplorer 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_ArgumentAnalyzerCheck the validity of argument(s) for Boolean Operations
BOP_BlockBuilderAuxiliary class to storage and operate with data of
connexity blocks inside the given ShapeSet

BOP_BlockIterator
BOP_Builder
BOP_BuilderToolsSome handy tools used by classes
BOP_ShellShell,
BOP_ShellSolid,
BOP_SolidSolid
to build a result
BOP_CheckResultInformation about faulty shapes and faulty types
can't be processed by Boolean Operations
BOP_CompositeClassifierThe Root class for algorithms
to classify composite Loops, i.e, Loops that
can be either a Shape, or a block of Elements.

BOP_ConnexityBlockAuxiliary class to store data about set
of connex shapes

BOP_CorrectTolerancesThe Set of static functions to provide valid values of
tolerances for shapes.
Tolerances becomes valid in terms of the checkshape.
BOP_DrawAuxiliary class to display intermediate results
in Draw's winowds for the debugging purposes

BOP_EdgeInfoThe auxiliary class to store data about edges
that have common vertex

BOP_EmptyBuilderPerforms Boolean Operation (BO) for shapes
in cases when one of arguments(or both) is(are) empty
BOP_FaceAreaBuilderThe 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_FaceBuilderThe algorithm to construct Faces from a WireEdgeSet

BOP_FaceInfoThe 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_LoopA 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_LoopClassifierRoot class to classify Loops in order to build Areas
BOP_LoopSetThe auxiliary class to store and iterate on Loop(s)
BOP_RefinerThe algorithm to provide the refinition
for a resulting shape of Boolean Operation
algorithm.
(not completed yet)
BOP_SDFWESFillerThe 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_SFSCorrectorAlgorithm 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_ShellFaceSetClass for set of faces and shells

BOP_ShellShellPerforms Boolean Operations (BO)
Common,Cut,Fuse for arguments that
are of type shell/shell

BOP_ShellSolidPerforms Boolean Operations (BO)
Common,Cut,Fuse for arguments of
shell/solid type
BOP_ShellSolidHistoryCollector
BOP_ShellSplitterAlgorithm to split (multiconnexed)
shells on a solid onto biconnexed shells
when each edge is shared by only two or one
faces
BOP_SolidAreaBuilderConstruct Areas for Solids from a Shell Faces Set
BOP_SolidBuilderConstruct Solids from a Shell Faces Set (SFS)
BOP_SolidClassifierThe auxiliary class to classify points with
a solid

BOP_SolidSolidPerforms Boolean Operations (BO)
Common,Cut,Fuse for solids as
arguments
BOP_SolidSolidHistoryCollector
BOP_WESCorrectorThe algorithm to change the Wire Edges Set (WES) contents.
The NewWES will contain only wires instead of wires and edges.
BOP_WireEdgeClassifierThe algorithm is to classify loops that
shapes are Wires, Element are Edge.
BOP_WireEdgeSetThe class containing data and methods
for a set of edges and wires
BOP_WireShapeThe Root class to perform a Boolean Operations (BO)
Common,Cut,Fuse between arguments when one of them is
a wire
BOP_WireShellThe 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_WireSolidThe 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_WireSplitterAlgorithm 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_DumpThe class provides dump service used for debugging
purposes

BOPTColStd_FailureThe class provides exception objects
BOPTColStd_IndexedDataMapNodeOfIndexedDataMapOfIntegerIndexedMapOfInteger
BOPTColStd_IndexedDataMapNodeOfIndexedDataMapOfIntegerInteger
BOPTColStd_IndexedDataMapNodeOfIndexedDataMapOfSWRInteger
BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger
BOPTColStd_IndexedDataMapOfIntegerInteger
BOPTColStd_IndexedDataMapOfSWRInteger
BOPTColStd_ListIteratorOfListOfListOfShape
BOPTColStd_ListNodeOfListOfListOfShape
BOPTColStd_ListOfListOfShape
BOPTColStd_ShapeWithRankThe auxiliary class provides structure to store a shape
and its rank

BOPTColStd_ShapeWithRankHasherThe 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_CheckerClass that provides the algorithm
to check a shape on self-interference.
BOPTools_CheckResultInformation about faulty shapes
and faulty types
BOPTools_CommonBlockThe class hold a structure for storing info about a couple
of pave blocks that are considered as common
BOPTools_CommonBlockAPIClass 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_CoupleOfIntegerAuxiliary class providing structure to
store info about a couple of integers
BOPTools_CoupleOfIntegerMapHasher
BOPTools_CurveClass holds the structure for storing information about
intersection curve and set of paves on it

BOPTools_DEInfoAuxiliary 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_DSFillerClass 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_EEInterferenceClass for storing an Edge/Edge
interference

BOPTools_ESInterferenceClass 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_InterferenceClass for storing information about an interference
that takes place between given shape and shape
with DS-index =aWith
BOPTools_InterferenceLineClass 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_InterferencePoolClass for storing information about
results of all interferences for all shapes
BOPTools_IteratorOfCoupleOfShapeThe 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_PaveClass for storing info about a vertex on an edge
BOPTools_PaveBlockClass for storing info about a couple
of neighbouring paves on an edge
BOPTools_PaveBlockIteratorClass providing iterations for PaveSet to
have the right order of paves along the edge

BOPTools_PaveBlockMapHasher
BOPTools_PaveFillerThe 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_PaveSetClass for storing/sorting paves that
belong to an edge
BOPTools_PCurveMakerClass provides computation p-curves for the edges and theirs
split parts
BOPTools_PointBetweenClass for storing geometry information about
a point between neighbouring paves along
an edge

BOPTools_QuickSortPave
BOPTools_RoughShapeIntersectorThe 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_ShapeShapeInterferenceRoot class for storing an Interference
between a couple BRep shapes
BOPTools_SolidStateFillerClass to compute states (3D) for the edges (and theirs
split parts), vertices, wires, faces, shells

BOPTools_SplitShapesPool
BOPTools_SSInterferenceClass 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_SSIntersectionAttributeClass is a container of three flags used
by intersection algorithm
BOPTools_StateFillerRoot class to compute states (3D)
BOPTools_ToolsThe class contains handy static functions
dealing with the topology
BOPTools_Tools2DThe class contains handy static functions
dealing with the topology
BOPTools_Tools3DThe class contains handy static functions
dealing with the topology
BOPTools_VEInterferenceClass for storing info about an Verex/Edge interference

BOPTools_VSInterferenceClass for storing info about an Verex/Face interference

BOPTools_VVInterferenceClass for storing an Verex/Vertex
interference
BOPTools_WireStateFillerClass to compute states (3D) for the edges (and theirs
split parts), vertices, wires

BRepAlgoThe 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_AsDesSD to store descendants and ascendants of Shapes.
BRepAlgo_BooleanOperationThe 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_CommonDescribes 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_CutDescribes 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_EdgeConnectorUsed 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_FaceRestrictorBuilds all the faces limited with a set of non
jointing and planars wires. if
<controlorientation> is false The Wires must have
correct orientations. Sinon orientation des wires
de telle sorte que les faces ne soient pas infinies
et qu'elles soient disjointes.
BRepAlgo_FuseDescribes 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_ImageStores link between a shape <s> and a shape <news>
obtained from <s>. <news> is an image of <s>.
BRepAlgo_LoopBuilds the loops from a set of edges on a face.
BRepAlgo_NormalProjectionThis class makes the projection of a wire on a
shape.
BRepAlgo_SectionConstruction 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_BooleanOperationThe 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_CommonThe 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_CutFile: 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_FuseThe 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_SectionComputes 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_AppFuncFunction to approximate by AppSurface
BRepBlend_AppFuncRootFunction to approximate by AppSurface
BRepBlend_AppFuncRstFunction to approximate by AppSurface for Edge/Face
BRepBlend_AppFuncRstRstFunction to approximate by AppSurface for Edge/Face
BRepBlend_AppSurf
BRepBlend_AppSurfaceUsed 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_CurvPointRadInvThis 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_RstRstLineBuilderThis 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_SurfCurvConstRadInvClass 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_SurfCurvEvolRadInvClass 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_SurfPointConstRadInvThis 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_SurfPointEvolRadInvThis 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_SurfRstLineBuilderThis 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
BRepBndLibThis package provides the bounding boxes for curves
and surfaces from BRepAdaptor.
Functions to add a topological shape to a bounding box
BRepBuilderAPIThe 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_CommandRoot class for all commands in BRepBuilderAPI.

Provides :

* Managements of the notDone flag.

* Catching of exceptions (not implemented).

* Logging (not implemented).
BRepBuilderAPI_CopyDuplication 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_FindPlaneDescribes 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_GTransformGeometric 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_MakeEdgeProvides 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_MakeEdge2dProvides 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_MakeFaceProvides 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_MakePolygonDescribes 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_MakeShapeThis is the root class for all shape
constructions. It stores the result.

It provides deferred methods to trace the history
of sub-shapes.
BRepBuilderAPI_MakeShellDescribes 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_MakeSolidDescribes 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_MakeVertexDescribes 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_MakeWireDescribes 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_ModifyShapeImplements 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_NurbsConvertConversion 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_SewingProvides 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_TransformGeometric 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.
BRepCheckThis package provides tools to check the validity
of the BRep.
BRepCheck_AnalyzerA framework to check the overall
validity of a shape. For a shape to be valid in Open
CASCADE, it - or its component subshapes - must respect certain
criteria. These criteria are checked by the function IsValid.
Once you have determined whether a shape is valid or not, you can
diagnose its specific anomalies and correct them using the services of
the ShapeAnalysis, ShapeUpgrade, and ShapeFix packages.
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_SClassifierProvides an algorithm to classify a point in a solid.
BRepClass3d_SolidClassifierProvides an algorithm to classify a point in a solid.
BRepClass3d_SolidExplorerProvide an exploration of a BRep Shape for the
classification.
BRepClass3d_SolidPassiveClassifier
BRepClass_EdgeThis class is used to send the description of an
Edge to the classifier. It contains an Edge and a
Face. So the PCurve of the Edge can be found.
BRepClass_FaceClassifierProvides Constructors.
BRepClass_FaceExplorerProvide an exploration of a BRep Face for the
classification.
BRepClass_FacePassiveClassifier
BRepClass_FClass2dOfFClassifier
BRepClass_FClassifier
BRepClass_IntersectorImplement the Intersector2d required by the classifier.
BRepExtrema_DistanceSSThis class allows to compute minimum distance between two shapes
(face edge vertex) and is used in DistShapeShape class.
BRepExtrema_DistShapeShapeThis 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_SolutionElemThis class is used to store information relative to the
minimum distance between two shapes.
BRepExtrema_UnCompatibleShape
BRepFeatBRepFeat 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_BuilderProvides the implementation of all methods
required by BRepCtx for class using a Builder from
LocOpe. All features have to inherit from this
class.
BRepFeat_FormProvides 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_GluerOne 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_LocalOperationOne 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_MakeCylindricalHoleProvides a tool to make cylindrical holes on a shape.
BRepFeat_MakeDPrismDescribes 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_MakeLinearFormBuilds 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_MakePipeConstructs 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_MakePrismDescribes 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_MakeRevolDescribes functions to build revolved shells from basis shapes.
BRepFeat_MakeRevolutionFormMakeRevolutionForm 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_RibSlotProvides 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_SplitShapeOne 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_ACRLawBuild Location Law, with a Wire. dans le cas du
contour guide et triedre par Abscisse Curviligne
Reduite

BRepFill_ApproxSeewingEvaluate the 3dCurve and the PCurves described in
a MultiLine from BRepFill. The parametrization of
those curves is not imposed by the Bissectrice.
The parametrization is given approximatively by
the abscissa of the curve3d.
BRepFill_CompatibleWiresConstructs 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_DraftLawBuild Location Law, with a Wire.
BRepFill_Edge3DLawBuild Location Law, with a Wire.
BRepFill_EdgeFaceAndOrder
BRepFill_EdgeOnSurfLawBuild Location Law, with a Wire and a Surface.
BRepFill_EvolvedConstructs a evolved volume from a spine (wire or face)
and a profile ( wire).
BRepFill_FaceAndOrderA structure containing Face and Order of constraint
BRepFill_FillingN-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_GeneratorCompute a topological surface ( a shell) using
generating wires. The face of the shell will be
ruled surfaces passing by the wires.
The wires must have the same number of edges.
BRepFill_ListIteratorOfListOfOffsetWire
BRepFill_ListNodeOfListOfOffsetWire
BRepFill_ListOfOffsetWire
BRepFill_LocationLawLocation Law on a Wire.
BRepFill_MultiLinePrivate 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_MultiLineToolPrivate class used to instantiate the continuous
approximations routines.
BRepFill_MyLeastSquareOfComputeCLine
BRepFill_NSectionsBuild Section Law, with N Sections

BRepFill_OffsetAncestorsThis class is used to find the generating shapes
of an OffsetWire.
BRepFill_OffsetWireConstructs a Offset Wire to a spine (wire or face)
on the left of spine.
BRepFill_PipeCreate 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_PipeShellPerform general sweeping construction
BRepFill_SectionTo store section definition
BRepFill_SectionLawBuild Section Law, with an Vertex, or an Wire
BRepFill_SectionPlacementPlace a shape in a local axis coordinate
BRepFill_SequenceNodeOfSequenceOfEdgeFaceAndOrder
BRepFill_SequenceNodeOfSequenceOfFaceAndOrder
BRepFill_SequenceNodeOfSequenceOfSection
BRepFill_SequenceOfEdgeFaceAndOrder
BRepFill_SequenceOfFaceAndOrder
BRepFill_SequenceOfSection
BRepFill_ShapeLawBuild Section Law, with an Vertex, or an Wire
BRepFill_SweepTopological Sweep Algorithm
BRepFill_TrimEdgeTool
BRepFill_TrimShellCorner
BRepFill_TrimSurfaceTool
BRepFilletAPI_LocalOperationConstruction of fillets on the edges of a Shell.
BRepFilletAPI_MakeChamferDescribes 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_MakeFilletDescribes 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_MakeFillet2dDescribes 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.
BRepGPropProvides 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_DomainArc iterator. Returns only Forward and Reversed edges from
the face in an undigested order.
BRepGProp_EdgeToolProvides 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_InterComputes the intersection between a face and a curve

BRepLibThe 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_CommandRoot class for all commands in BRepLib.

Provides :

* Managements of the notDone flag.

* Catching of exceptions (not implemented).

* Logging (not implemented).
BRepLib_FindSurfaceProvides 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_FuseEdgesThis class can detect vertices in a face that can
be considered useless and then perform the fuse of
the edges and remove the useless vertices. By
useles vertices, we mean :
* 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_MakeEdgeProvides 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_MakeEdge2dProvides 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_MakeFaceProvides 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_MakePolygonClass 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_MakeShapeThis is the root class for all shape
constructions. It stores the result.

It provides deferred methods to trace the history
of sub-shapes.
BRepLib_MakeShellProvides methos to build shells.

Build a shell from a set of faces.
Build a shell from a non C2 surface.
BRepLib_MakeSolidMakes a solid from compsolid or shells.
BRepLib_MakeVertexProvides methods to build vertices.
BRepLib_MakeWireProvides 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_ExplorerConstruct an explorer from wires, face, set of curves
from Geom2d to compute the bisecting Locus.
BRepMAT2d_LinkTopoBiloConstucts links between the Face of the explorer and
the BasicElts contained in the bisecting locus.
BRepMAT2d_SequenceNodeOfSequenceOfBasicElt
BRepMAT2d_SequenceOfBasicElt
BRepMeshInstantiated 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_FastDiscretAlgorithm 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_IncrementalMeshBuilds 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_AnalyseAnalyse 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_Inter2dComputes the intersections betwwen edges on a face
stores result is SD as AsDes from BRepOffset.
BRepOffset_Inter3dComputes 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_OffsetClass for the creation of Offseting.
BRepOffset_Tool
BRepOffsetAPI_DataMapIteratorOfDataMapOfShapeSequenceOfShape
BRepOffsetAPI_DataMapNodeOfDataMapOfShapeSequenceOfShape
BRepOffsetAPI_DataMapOfShapeSequenceOfShape
BRepOffsetAPI_DraftAngleTaper-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_FindContigousEdgesProvides 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_MakeDraftBuild a draft surface along a wire
BRepOffsetAPI_MakeEvolvedDescribes 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_MakeFillingN-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_MakeOffsetDescribes 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_MakeOffsetShapeDescribes 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_MakePipeDescribes 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_MakePipeShellThis 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_MakeThickSolidDescribes 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_NormalProjectionA 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_ThruSectionsDescribes 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_BuilderImplements the abstract Builder with the BRep Builder
BRepPrim_ConeImplement the cone primitive.
BRepPrim_CylinderCylinder primitive.
BRepPrim_FaceBuilderThe 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_RevolutionImplement the OneAxis algoritm for a revolution
surface.
BRepPrim_SphereImplements the sphere primitive
BRepPrim_TorusImplements the torus primitive
BRepPrim_WedgeProvides constructors without Builders.
BRepPrimAPI_MakeBoxDescribes 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_MakeConeDescribes 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_MakeCylinderDescribes 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_MakeHalfSpaceDescribes 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_MakeOneAxisThe abstract class MakeOneAxis is the root class of
algorithms used to construct rotational primitives.
BRepPrimAPI_MakePrismDescribes 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_MakeRevolClass 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_MakeRevolutionDescribes 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_MakeSphereDescribes 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_MakeSweepThe 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_MakeTorusDescribes 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_MakeWedgeDescribes 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_ProjectionThe Projection class provides conical and
cylindrical projections of Edge or Wire on
a Shape from TopoDS. The result will be a Edge
or Wire from TopoDS.
BRepSweep_Array2OfShapesOfNumLinearRegularSweep
BRepSweep_BuilderImplements the abstract Builder with the BRep Builder
BRepSweep_IteratorThis class provides iteration services required by
the Generating Line (TopoDS Shape) of a BRepSweep.
This tool is used to iterate on the direct
sub-shapes of a Shape.

BRepSweep_NumLinearRegularSweep
BRepSweep_PrismProvides natural constructors to build BRepSweep
translated swept Primitives.
BRepSweep_RevolProvides natural constructors to build BRepSweep
rotated swept Primitives.
BRepSweep_RotationProvides an algorithm to build object by
Rotation sweep.
BRepSweep_SequenceNodeOfSequenceOfShapesOfNumLinearRegularSweep
BRepSweep_SequenceOfShapesOfNumLinearRegularSweep
BRepSweep_ToolProvides the indexation and type analysis services
required by the TopoDS generating Shape of BRepSweep.

BRepSweep_TranslationProvides an algorithm to build object by
translation sweep.
BRepSweep_TrsfThis 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
ChFi2dThis package contains the algorithms used to build
fillets or chamfers on planar wire.
ChFi2d_BuilderThis class contains the algorithm used to build
fillet on planar wire.
ChFi3dCreation of spatial fillets on a solid.
ChFi3d_BuilderRoot class for calculation of surfaces (fillets,
chamfers) destined to smooth edges of
a gap on a Shape and the reconstruction of the Shape.
ChFi3d_ChBuilderConstruction tool for 3D chamfers on edges.
ChFi3d_FilBuilderTool of construction of fillets 3d on edges.
ChFi3d_SearchSingF(t) = (C1(t) - C2(t)).(C1'(t) - C2'(t));
ChFiDS_ChamfSpineProvides data specific to chamfers
distances on each of faces.
ChFiDS_CircSectionA Section of fillet.
ChFiDS_CommonPoint
ChFiDS_ElSpineElementary Spine for cheminements and approximations.
ChFiDS_FaceInterferenceInterference face/fillet
ChFiDS_FilSpineProvides 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_MapEncapsulation of IndexedDataMapOfShapeListOfShape.
ChFiDS_RegulStorage 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_SpineContient 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_StripeData structure associe au coin
ChFiDS_StripeArray1
ChFiDS_StripeMap
ChFiDS_SurfData
ChFiKPart_ComputeDataMethodes 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_ContAnaThis 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_BattenConstructs curves with a constant or linearly increasing
section to be used in the design of wooden or plastic
battens. These curves are two-dimensional, and
simulate physical splines or battens.
FairCurve_BattenLawThis class compute the Heigth of an batten
FairCurve_DistributionOfEnergyAbstract class to use the Energy of an FairCurve
FairCurve_DistributionOfJerkCompute the "Jerk" distribution.
FairCurve_DistributionOfSaggingCompute the Sagging Distribution
FairCurve_DistributionOfTensionCompute the Tension Distribution
FairCurve_EnergyNecessary methodes to compute the energy of an FairCurve.
FairCurve_EnergyOfBattenEnergy Criterium to minimize in Batten.
FairCurve_EnergyOfMVCEnergy Criterium to minimize in MinimalVariationCurve.
FairCurve_MinimalVariationComputes 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_NewtonAlgorithme of Optimization used to make "FairCurve"
FilletSurf_BuilderAPI giving the following geometric information about fillets
list of corresponding NUBS surfaces
for each surface:
the 2 support faces
on each face: the 3d curve and the corresponding 2d curve
the 2d curves on the fillet
status of start and end section of the fillet
first and last parameter on edge of the fillet.
FilletSurf_InternalBuilderThis class is private. It is used by the class Builder
from FilletSurf. It computes geometric information about fillets.
GccAna_Circ2d2TanOnDescribes 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_Circ2d2TanRadThis class implements the algorithms used to
create 2d circles tangent to 2
points/lines/circles and with a given radius.
For each construction methods arguments are:
- 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_Circ2d3TanThis 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_Circ2dBisecThis class describes functions for building bisecting curves between two 2D circles.
A bisecting curve between two circles is a curve such
that each of its points is at the same distance from the
two circles. It can be an ellipse, hyperbola, circle or line,
depending on the relative position of the two circles.
The algorithm computes all the elementary curves which
are solutions. There is no solution if the two circles are coincident.
A Circ2dBisec object provides a framework for:
- defining the construction of the bisecting curves,
- implementing the construction algorithm, and consulting the result.
GccAna_Circ2dTanCenThis class implements the algorithms used to
create 2d circles tangent to an entity and
centered on a point.
The arguments of all construction methods are :
- 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_Circ2dTanOnRadThis class implements the algorithms used to
create a 2d circle tangent to a 2d entity,
centered on a curv and with a given radius.
The arguments of all construction methods are :
- 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_CircLin2dBisecDescribes functions for building bisecting curves between a 2D line and a 2D circle.
A bisecting curve between a circle and a line is a curve
such that each of its points is at the same distance from
the circle and the line. It can be a parabola or a line,
depending of the relative position of the line and the
circle. The algorithm computes all the elementary curves which are solutions.
A CircLin2dBisec object provides a framework for:
- defining the construction of the bisecting curves,
- implementing the construction algorithm, and
- consulting the result.
GccAna_CircPnt2dBisecDescribes functions for building a bisecting curve
between a 2D circle and a point.
A bisecting curve between a circle and a point is such a
curve that each of its points is at the same distance from
the circle and the point. It can be an ellipse, hyperbola,
circle or line, depending on the relative position of the
point and the circle. The algorithm computes all the
elementary curves which are solutions.
A CircPnt2dBisec object provides a framework for:
- defining the construction of the bisecting curves,
- implementing the construction algorithm, and
- consulting the result.
GccAna_Lin2d2TanThis class implements the algorithms used to
create 2d lines tangent to 2 other elements which
can be circles or points.
Describes functions for building a 2D line:
- 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_Lin2dBisecDescribes functions for building bisecting lines between two 2D lines.
A bisecting line between two lines is such that each of its
points is at the same distance from the two lines.
If the two lines are secant, there are two orthogonal
bisecting lines which share the angles made by the two
straight lines in two equal parts. If D1 and D2 are the
unit vectors of the two straight lines, those of the two
bisecting lines are collinear with the following vectors:
- 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_Lin2dTanOblThis class implements the algorithms used to
create 2d line tangent to a circle or a point and
making an angle with a line.
The angle is in radians.
The origin of the solution is the tangency point
with the first argument.
Its direction is making an angle Angle with the
second argument.
GccAna_Lin2dTanParThis class implements the algorithms used to create 2d
line tangent to a circle or a point and parallel to
another line.
The solution has the same orientation as the
second argument.
Describes functions for building a 2D line parallel to a line and:
- 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_Lin2dTanPerThis class implements the algorithms used to
create 2d lines tangent to a circle or a point and
perpendicular to a line or a circle.
Describes functions for building a 2D line perpendicular
to a line and:
- 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_LinPnt2dBisecDescribes functions for building bisecting curves between a 2D line and a point.
A bisecting curve between a line and a point is such a
curve that each of its points is at the same distance from
the circle and the point. It can be a parabola or a line,
depending on the relative position of the line and the
circle. There is always one unique solution.
A LinPnt2dBisec object provides a framework for:
- defining the construction of the bisecting curve,
- implementing the construction algorithm, and
- consulting the result.
GccAna_NoSolution
GccAna_Pnt2dBisecThis class implements the algorithms used to
create the bisecting line between two 2d points
Describes functions for building a bisecting line between two 2D points.
The bisecting line between two points is the bisector of
the segment which joins the two points, if these are not coincident.
The algorithm does not find a solution if the two points are coincident.
A Pnt2dBisec object provides a framework for:
- defining the construction of the bisecting line,
- implementing the construction algorithm, and consulting the result.
GccEntThis 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_QualifiedCircCreates a qualified 2d Circle.
A qualified 2D circle is a circle (gp_Circ2d circle) with a
qualifier which specifies whether the solution of a
construction algorithm using the qualified circle (as an argument):
- 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_QualifiedLinDescribes a qualified 2D line.
A qualified 2D line is a line (gp_Lin2d line) with a
qualifier which specifies whether the solution of a
construction algorithm using the qualified line (as an argument):
- 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_BCircDescribes a circle as a bisecting curve between two 2D
geometric objects (such as circles or points).
GccInt_BElipsDescribes an ellipse as a bisecting curve between two
2D geometric objects (such as circles or points).
GccInt_BHyperDescribes a hyperbola as a bisecting curve between two
2D geometric objects (such as circles or points).
GccInt_BisecThe 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_BLineDescribes a line as a bisecting curve between two 2D
geometric objects (such as lines, circles or points).
GccInt_BParabDescribes a parabola as a bisecting curve between two
2D geometric objects (such as lines, circles or points).
GccInt_BPointDescribes a point as a bisecting object between two 2D geometric objects.
GccIter_IsParallel
Geom2dAPI_ExtremaCurveCurveDescribes functions for computing all the extrema
between two 2D curves.
An ExtremaCurveCurve algorithm minimizes or
maximizes the distance between a point on the first
curve and a point on the second curve. Thus, it
computes the start point and end point of
perpendiculars common to the two curves (an
intersection point is not an extremum except where
the two curves are tangential at this point).
Solutions consist of pairs of points, and an extremum
is considered to be a segment joining the two points of a solution.
An ExtremaCurveCurve object provides a framework for:
- 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_InterCurveCurveThis 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_InterpolateThis class is used to interpolate a BsplineCurve
passing through an array of points, with a C2
Continuity if tangency is not requested at the point.
If tangency is requested at the point the continuity will
be C1. If Perodicity is requested the curve will be closed
and the junction will be the first point given. The curve will than be only C1
The curve is defined by a table of points through which it passes, and if required
by a parallel table of reals which gives the value of the parameter of each point through
which the resulting BSpline curve passes, and by vectors tangential to these points.
An Interpolate object provides a framework for: defining the constraints of the BSpline curve,
- implementing the interpolation algorithm, and consulting the results.
Geom2dAPI_PointsToBSplineThis class is used to approximate a BsplineCurve
passing through an array of points, with a given
Continuity.
Describes functions for building a 2D BSpline
curve which approximates a set of points.
A PointsToBSpline object provides a framework for:
- defining the data of the BSpline curve to be built,
- implementing the approximation algorithm, and
- consulting the results
Geom2dAPI_ProjectPointOnCurveThis class implements methods for computing all the orthogonal
projections of a 2D point onto a 2D curve.
Geom2dGccThe 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_Circ2d2TanOnThis class implements the algorithms used to
create 2d circles TANgent to 2 entities and
having the center ON a curve.
The order of the tangency argument is always
QualifiedCirc, QualifiedLin, QualifiedCurv, Pnt2d.
the arguments are :
- The two tangency arguments.
- The center line.
- The parameter for each tangency argument which
is a curve.
- The tolerance.
Geom2dGcc_Circ2d2TanRadThis class implements the algorithms used to
create 2d circles tangent to one curve and a
point/line/circle/curv and with a given radius.
For each construction methods arguments are:
- 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_Circ2d3TanThis class implements the algorithms used to
create 2d circles tangent to 3 points/lines/circles/
curves with one curve or more.
The arguments of all construction methods are :
- 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_Circ2dTanCenThis class implements the algorithms used to
create 2d circles tangent to a curve and
centered on a point.
The arguments of all construction methods are :
- 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_Circ2dTanOnRadThis class implements the algorithms used to
create a 2d circle tangent to a 2d entity,
centered on a 2d entity and with a given radius.
More than one argument must be a curve.
The arguments of all construction methods are :
- 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_Lin2d2TanThis class implements the algorithms used to
create 2d lines tangent to 2 other elements which
can be circles, curves or points.
More than one argument must be a curve.
Describes functions for building a 2D line:
- 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_Lin2dTanOblThis class implements the algorithms used to
create 2d line tangent to a curve QualifiedCurv and
doing an angle Angle with a line TheLin.
The angle must be in Radian.
Describes functions for building a 2D line making a given
angle with a line and tangential to a curve.
A Lin2dTanObl object provides a framework for:
- 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_QualifiedCurveDescribes functions for building a qualified 2D curve.
A qualified 2D curve is a curve with a qualifier which
specifies whether the solution of a construction
algorithm using the qualified curve (as an argument):
- 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
GeomAPIThe 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 :

D = GeomAPI_ProjectPointOnCurve(P,C);

or

GeomAPI_ProjectPointOnCurve PonC(P,C);
D = PonC.LowerDistance();

GeomAPI_ExtremaCurveCurveDescribes functions for computing all the extrema
between two 3D curves.
An ExtremaCurveCurve algorithm minimizes or
maximizes the distance between a point on the first
curve and a point on the second curve. Thus, it
computes start and end points of perpendiculars
common to the two curves (an intersection point is
not an extremum unless the two curves are tangential at this point).
Solutions consist of pairs of points, and an extremum
is considered to be a segment joining the two points of a solution.
An ExtremaCurveCurve object provides a framework for:
- 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_ExtremaCurveSurfaceDescribes functions for computing all the extrema
between a curve and a surface.
An ExtremaCurveSurface algorithm minimizes or
maximizes the distance between a point on the curve
and a point on the surface. Thus, it computes start
and end points of perpendiculars common to the
curve and the surface (an intersection point is not an
extremum except where the curve and the surface
are tangential at this point).
Solutions consist of pairs of points, and an extremum
is considered to be a segment joining the two points of a solution.
An ExtremaCurveSurface object provides a framework for:
- 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_ExtremaSurfaceSurfaceDescribes functions for computing all the extrema
between two surfaces.
An ExtremaSurfaceSurface algorithm minimizes or
maximizes the distance between a point on the first
surface and a point on the second surface. Results
are start and end points of perpendiculars common to the two surfaces.
Solutions consist of pairs of points, and an extremum
is considered to be a segment joining the two points of a solution.
An ExtremaSurfaceSurface object provides a framework for:
- 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_IntCSThis class implements methods for
computing intersection points and segments between a
GeomAPI_InterpolateThis class is used to interpolate a BsplineCurve
passing through an array of points, with a C2
Continuity if tangency is not requested at the point.
If tangency is requested at the point the continuity will
be C1. If Perodicity is requested the curve will be closed
and the junction will be the first point given. The curve
will than be only C1
Describes functions for building a constrained 3D BSpline curve.
The curve is defined by a table of points
through which it passes, and if required:
- 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_IntSSThis class implements methods for
computing the intersection curves between two surfaces.
The result is curves from Geom. The "domain" used for
a surface is the natural parametric domain
unless the surface is a RectangularTrimmedSurface
from Geom.
GeomAPI_PointsToBSplineThis class is used to approximate a BsplineCurve
passing through an array of points, with a given Continuity.
Describes functions for building a 3D BSpline
curve which approximates a set of points.
A PointsToBSpline object provides a framework for:
- defining the data of the BSpline curve to be built,
- implementing the approximation algorithm, and consulting the results.
GeomAPI_PointsToBSplineSurfaceThis class is used to approximate or interpolate
a BSplineSurface passing through an Array2 of
points, with a given continuity.
Describes functions for building a BSpline
surface which approximates or interpolates a set of points.
A PointsToBSplineSurface object provides a framework for:
- defining the data of the BSpline surface to be built,
- implementing the approximation algorithm
or the interpolation algorithm, and consulting the results.
GeomAPI_ProjectPointOnCurveThis class implements methods for computing all the orthogonal
projections of a 3D point onto a 3D curve.
GeomAPI_ProjectPointOnSurfThis class implements methods for computing all the orthogonal
projections of a point onto a surface.
GeomFillTools and Data to filling Surface and Sweep Surfaces
GeomFill_AppSurf
GeomFill_AppSweep
GeomFill_Array1OfLocationLaw
GeomFill_Array1OfSectionLaw
GeomFill_BezierCurvesThis class provides an algorithm for constructing a Bezier surface filled from
contiguous Bezier curves which form its boundaries.
The algorithm accepts two, three or four Bezier curves
as the boundaries of the target surface.
A range of filling styles - more or less rounded, more or less flat - is available.
A BezierCurves object provides a framework for:
- 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_BoundaryRoot 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_BoundWithSurfDefines 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_BSplineCurvesAn algorithm for constructing a BSpline surface filled
from contiguous BSpline curves which form its boundaries.
The algorithm accepts two, three or four BSpline
curves as the boundaries of the target surface.
A range of filling styles - more or less rounded, more
or less flat - is available.
A BSplineCurves object provides a framework for:
- 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_CircularBlendFuncCircular Blend Function to approximate by
SweepApproximation from Approx
GeomFill_ConstantBiNormalDefined an Trihedron Law where the BiNormal, is fixed
GeomFill_ConstrainedFillingAn algorithm for constructing a BSpline surface filled
from a series of boundaries which serve as path
constraints and optionally, as tangency constraints.
The algorithm accepts three or four curves as the
boundaries of the target surface.
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_CoonsAlgPatchProvides evaluation methods on an algorithmic
patch defined by its boundaries and blending
functions.
GeomFill_CornerStateClass (should be a structure) storing the
informations about continuity, normals
parallelism, coons conditions and bounds tangents
angle on the corner of contour to be filled.
GeomFill_CorrectedFrenetDefined an Corrected Frenet Trihedron Law It is
like Frenet with an Torsion's minimization
GeomFill_CurveAndTrihedronDefine 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_DarbouxDefines Darboux case of Frenet Trihedron Law
GeomFill_DegeneratedBoundDescription of a degenerated boundary (a point).
GeomFill_DraftTrihedron
GeomFill_EvolvedSectionDefine an Constant Section Law
GeomFill_Filling
GeomFill_FixedDefined an constant TrihedronLaw
GeomFill_FrenetDefined Frenet Trihedron Law
GeomFill_FunctionDraft
GeomFill_FunctionGuide
GeomFill_GeneratorCreate 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_GuideTrihedronACTrihedron in the case of a sweeping along a guide curve.
defined by curviline absciss
GeomFill_GuideTrihedronPlanTrihedron 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_LocationLawTo 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_NSectionsDefine a Section Law by N Sections
GeomFill_PipeDescribes functions to construct pipes. A pipe is built by
sweeping a curve (the section) along another curve (the path).
The Pipe class provides the following types of construction:
- 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_PolynomialConvertorTo convert circular section in polynome
GeomFill_ProfilerEvaluation of the common BSplineProfile of a group
of curves from Geom. All the curves will have the
same degree, the same knot-vector, so the same
number of poles.
GeomFill_QuasiAngularConvertorTo convert circular section in QuasiAngular Bezier
form
GeomFill_SectionGeneratorGives the functions needed for instantiation from
AppSurf in AppBlend. Allow to evaluate a surface
passing by all the curves if the Profiler.
GeomFill_SectionLawTo define section law in sweeping
GeomFill_SectionPlacementTo place section in sweep Function
GeomFill_SequenceNodeOfSequenceOfCurve
GeomFill_SequenceNodeOfSequenceOfTrsf
GeomFill_SequenceOfCurve
GeomFill_SequenceOfTrsf
GeomFill_SimpleBoundDefines a 3d curve as a boundary for a
GeomFill_ConstrainedFilling algorithm.
This curve is unattached to an existing surface.D
GeomFill_SnglrFuncTo represent function C'(t)^C''(t)
GeomFill_Stretch
GeomFill_SweepGeometrical Sweep Algorithm
GeomFill_SweepFunctionFunction to approximate by SweepApproximation from
Approx. To bulid general sweep Surface.
GeomFill_SweepSectionGeneratorClass for instantiation of AppBlend.
evaluate the sections of a sweep surface.
GeomFill_TensorUsed to store the "gradient of gradient"
GeomFill_TgtFieldRoot class defining the methods we need to make an
algorithmic tangents field.
GeomFill_TgtOnCoonsDefines an algorithmic tangents field on a
boundary of a CoonsAlgPatch.
GeomFill_TrihedronLawTo define Trihedron along one Curve
GeomFill_TrihedronWithGuideTo define Trihedron along one Curve with a guide



GeomFill_UniformSectionDefine 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_AijA structure containing indexes of two normals and its cross product
GeomPlate_Array1OfHCurveOnSurface
GeomPlate_Array1OfSequenceOfReal
GeomPlate_BuildAveragePlaneThis class computes an average inertial plane with an
array of points.
GeomPlate_BuildPlateSurfaceThis class provides an algorithm for constructing such a plate surface that
it conforms to given curve and/or point constraints.
The algorithm accepts or constructs an initial surface
and looks for a deformation of it satisfying the
constraints and minimizing energy input.
A BuildPlateSurface object provides a framework for:
- defining or setting constraints
- implementing the construction algorithm
- consulting the result.
GeomPlate_CurveConstraintDefines curves as constraints to be used to deform a surface.
GeomPlate_HArray1OfHCurveOnSurface
GeomPlate_HArray1OfSequenceOfReal
GeomPlate_HSequenceOfCurveConstraint
GeomPlate_HSequenceOfPointConstraint
GeomPlate_MakeApproxAllows you to convert a GeomPlate surface into a BSpline.
GeomPlate_PlateG0Criterion
GeomPlate_PlateG1Criterion
GeomPlate_PointConstraintDefines points as constraints to be used to deform a surface.
GeomPlate_SequenceNodeOfSequenceOfAij
GeomPlate_SequenceNodeOfSequenceOfCurveConstraint
GeomPlate_SequenceNodeOfSequenceOfPointConstraint
GeomPlate_SequenceOfAij
GeomPlate_SequenceOfCurveConstraint
GeomPlate_SequenceOfPointConstraint
GeomPlate_SurfaceDescribes 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_HatcherThe 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_LineStores 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_ParameterStores 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
HLRAlgoIn 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_CoincidenceThe 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_EdgesBlockAn 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_EdgeStatusThis 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_IntersectionDescribes an intersection on an edge to hide.
Contains a parameter and a state (ON = on the
face, OUT = above the face, IN = under the Face)
HLRAlgo_ListIteratorOfInterferenceList
HLRAlgo_ListIteratorOfListOfBPoint
HLRAlgo_ListNodeOfInterferenceList
HLRAlgo_ListNodeOfListOfBPoint
HLRAlgo_ListOfBPoint
HLRAlgo_PolyAlgoTo remove Hidden lines on Triangulations.
HLRAlgo_PolyData
HLRAlgo_PolyHidingData
HLRAlgo_PolyInternalData
HLRAlgo_PolyInternalNode
HLRAlgo_PolyInternalSegment
HLRAlgo_PolyShellData
HLRAlgo_ProjectorImplements 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_WiresBlockA WiresBlock is a set of Blocks. It is used by the
DataStructure to structure the Edges.

A WiresBlock contains :

* An Array of Blocks.
HLRBRepHidden Lines Removal
algorithms on the BRep DataStructure.

The class PolyAlgo is used to remove Hidden lines
on Shapes with Triangulations.
HLRBRep_AlgoA 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_AreaLimitThe 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_BiPnt2DContains the colors of a shape.
HLRBRep_BiPointContains the colors of a shape.
HLRBRep_BSurfaceTool
HLRBRep_CInter
HLRBRep_CLProps
HLRBRep_CLPropsATool
HLRBRep_CurveDefines 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_EdgeFaceToolThe EdgeFaceTool computes the UV coordinates at a
given parameter on a Curve and a Surface. It also
compute the signed curvature value in a direction
at a given u,v point on a surface.
HLRBRep_EdgeIList
HLRBRep_EdgeInterferenceToolImplements the methods required to instantiates
the EdgeInterferenceList from HLRAlgo.
HLRBRep_ExactIntersectionPointOfTheIntPCurvePCurveOfCInter
HLRBRep_FaceData
HLRBRep_FaceIterator
HLRBRep_Hider
HLRBRep_HLRToShapeA framework for filtering the computation
results of an HLRBRep_Algo algorithm by extraction.
From the results calculated by the algorithm on
a shape, a filter returns the type of edge you
want to identify. You can choose any of the following types of output:
- 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_IntersectorThe Intersector computes 2D intersections of the
projections of 3D curves.

It can also computes the intersection of a 3D line
and a surface.
HLRBRep_LineToolThe 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_PolyAlgoA 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_PolyHLRToShapeA framework for filtering the computation
results of an HLRBRep_Algo algorithm by extraction.
From the results calculated by the algorithm on
a shape, a filter returns the type of edge you
want to identify. You can choose any of the following types of output:
- 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_ShapeBoundsContains a Shape and the bounds of its vertices,
edges and faces in the DataStructure.
HLRBRep_ShapeToHLRCompute 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_DataStores the results of the OutLine and IsoLine
processes.
HLRTopoBRep_DataMapIteratorOfDataMapOfShapeFaceData
HLRTopoBRep_DataMapIteratorOfMapOfShapeListOfVData
HLRTopoBRep_DataMapNodeOfDataMapOfShapeFaceData
HLRTopoBRep_DataMapNodeOfMapOfShapeListOfVData
HLRTopoBRep_DataMapOfShapeFaceData
HLRTopoBRep_DSFillerProvides methods to fill a HLRTopoBRep_Data.
HLRTopoBRep_FaceDataContains 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_IConicToolImplementation of the ImpTool from IntImpParGen
for conics of gp.
IntCurve_IntConicConicProvides 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_PConicThis class represents a conic from gp as a
parametric curve ( in order to be used by the
class PConicTool from IntCurve).
IntCurve_PConicToolImplementation of the ParTool from IntImpParGen
for conics of gp, using the class PConic from IntCurve.
IntCurve_ProjectOnPConicToolThis class provides a tool which computes the parameter
of a point near a parametric conic.
IntCurvesFace_Intersector
IntCurvesFace_ShapeIntersector
IntCurveSurface_HInter
IntCurveSurface_Intersection
IntCurveSurface_IntersectionPointDefinition of an interserction point between a
curve and a surface.
IntCurveSurface_IntersectionSegmentA 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
IntfInterference 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_InterferenceDescribes the Interference computation result
between polygon2d or polygon3d or polyhedron.
Intf_SectionLineDescribe a polyline of intersection between two
polyhedra as a sequence of points of intersection.
Intf_SectionPointDescribes an intersection point between polygons and
polyedra.
Intf_SeqOfSectionLine
Intf_SeqOfSectionPoint
Intf_SeqOfTangentZone
Intf_SequenceNodeOfSeqOfSectionLine
Intf_SequenceNodeOfSeqOfSectionPoint
Intf_SequenceNodeOfSeqOfTangentZone
Intf_TangentZoneDescribes a zone of tangence between polygons or
polyhedra as a sequence of points of intersection.
Intf_ToolProvides services to create box for infinites
lines in a given contexte.
IntImpParGenGives a generic algorithm to intersect Implicit Curves
and Bounded Parametric Curves.

Level: Internal
IntImpParGen_ImpToolTemplate class for an implicit curve.
IntPatch_APolygoOfTheRstIntOfIntersection
IntPatch_CSFunctionOfTheRstIntOfIntersection
IntPatch_CurvIntSurfOfTheRstIntOfIntersection
IntPatch_HCurve2dTool
IntPatch_HInterTool
IntPatch_HSurfaceTool
IntPatch_Intersection
IntPatch_LineDefinition 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_PolygoToolTool 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_PlaneSectionDetermines 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_ShapeSectionDetermines 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_DomainDefinition of the domain of parameter on a 2d-curve.
Most of the time, a domain is defined by two extremities.
An extremity is made of :
- 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_IntersectionDefines the root class of all the Intersections
between two 2D-Curves, and provides all the methods
about the results of the Intersections Algorithms.
IntRes2d_IntersectionPointDefinition of an intersection point between two
2D curves.
IntRes2d_IntersectionSegmentDefinition of an intersection curve between
two 2D curves.
IntRes2d_SequenceNodeOfSequenceOfIntersectionPoint
IntRes2d_SequenceNodeOfSequenceOfIntersectionSegment
IntRes2d_SequenceOfIntersectionPoint
IntRes2d_SequenceOfIntersectionSegment
IntRes2d_TransitionDefinition of the type of transition near an
intersection point between two curves. The transition
is either a "true transition", which means that one of
the curves goes inside or outside the area defined by
the other curve near the intersection, or a "touch <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_IntervalsThe class Intervals is a sorted sequence of non
overlapping Real Intervals.
Intrv_SequenceNodeOfSequenceOfInterval
Intrv_SequenceOfInterval
IntStart_SITopolToolTemplate class for a topological tool.
This tool is linked with the surface on which
the classification has to be made.
IntSurfThis package provides resources for
all the packages concerning the intersection
between surfaces.
IntSurf_CoupleCreation d 'un couple de 2 entiers
IntSurf_InteriorPointDefinition of a point solution of the
intersection between an implicit an a
parametrised surface. These points are
passing points on the intersection lines,
or starting points for the closed lines
on the parametrised surface.
IntSurf_InteriorPointToolThis 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_PntOn2SThis class defines the geometric informations
for an intersection point between 2 surfaces :
The coordinates ( Pnt from gp ), and two
parametric coordinates.
IntSurf_Quadric
IntSurf_QuadricToolThis class provides a tool on a quadric that can be
used to instantiates the Walking algorithmes (see
package IntWalk) with a Quadric from IntSurf
as implicit surface.
IntSurf_SequenceNodeOfSequenceOfCouple
IntSurf_SequenceNodeOfSequenceOfInteriorPoint
IntSurf_SequenceNodeOfSequenceOfPathPoint
IntSurf_SequenceNodeOfSequenceOfPntOn2S
IntSurf_SequenceOfCouple
IntSurf_SequenceOfInteriorPoint
IntSurf_SequenceOfPathPoint
IntSurf_SequenceOfPntOn2S
IntSurf_TransitionDefinition of the transition at the intersection
between an intersection line and a restriction curve
on a surface.
IntToolsContains classes for intersection and classification
purposes and accompanying classes
IntTools_Array1OfRange
IntTools_Array1OfRoots
IntTools_BaseRangeSample
IntTools_BeanBeanIntersectorThe 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_BeanFaceIntersectorThe class BeanFaceIntersector computes ranges of parameters on
the curve of a bean(part of edge) that bound the parts of bean which
are on the surface of a face according to edge and face tolerances.
Warning: The real boundaries of the face are not taken into account,
Most of the result parts of the bean lays only inside the region of the surface,
which includes the inside of the face. And the parts which are out of this region can be
excluded from the result.
IntTools_CArray1OfInteger
IntTools_CArray1OfReal
IntTools_CommonPrtThe class is to describe a common part
between two edges in 3-d space.
IntTools_CompareAuxiliary class to provide a sorting Roots.
IntTools_CompareRangeAuxiliary class to provide a sorting Ranges,
taking into account a value of Left .
IntTools_ContextThe 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_EdgeEdgeThe class provides Edge/Edge algorithm to determine
common parts between two edges in 3-d space.
Common parts can be : Vertices or Edges.

IntTools_EdgeFaceThe class provides Edge/Face algorithm to determine
common parts between edge and face in 3-d space.
Common parts can be : Vertices or Edges.

IntTools_FaceFaceThis class provides the intersection of
face's underlying surfaces.
IntTools_FClass2dClass 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_LineConstructorSplits 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_MarkedRangeSetClass MarkedRangeSet provides continuous set of ranges marked with flags
IntTools_PntOn2FacesContains two points PntOnFace from IntTools and a flag
IntTools_PntOnFaceContains a Face, a 3d point, corresponded UV parameters and a flag
IntTools_QuickSort
IntTools_QuickSortRange
IntTools_RangeThe class describes the 1-d range
[myFirst, myLast].
IntTools_RootThe 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_ShrunkRangeThe 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_ToolsThe class contains handy static functions
dealing with the geometry and topology.
IntTools_TopolToolClass redefine methods of TopolTool from Adaptor3d
concerning sample points
LawMultiple services concerning 1d functions.
Law_BSpFuncLaw 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_BSplineDefinition 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_BSplineKnotSplittingFor a B-spline curve the discontinuities are localised at the
knot values and between two knots values the B-spline is
infinitely continuously differentiable.
At a knot of range index the continuity is equal to :
Degree - Mult (Index) where Degree is the degree of the
basis B-spline functions and Mult the multiplicity of the knot
of range Index.
If for your computation you need to have B-spline curves with a
minima of continuity it can be interesting to know between which
knot values, a B-spline curve arc, has a continuity of given order.
This algorithm computes the indexes of the knots where you should
split the curve, to obtain arcs with a constant continuity given
at the construction time. The splitting values are in the range
[FirstUKnotValue, LastUKnotValue] (See class B-spline curve from
package Geom).
If you just want to compute the local derivatives on the curve you
don't need to create the B-spline curve arcs, you can use the
functions LocalD1, LocalD2, LocalD3, LocalDN of the class
BSplineCurve.
Law_CompositeLoi 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_ConstantLoi constante
Law_FunctionRoot class for evolution laws.
Law_InterpolProvides an evolution law that interpolates a set
of parameter and value pairs (wi, radi)
Law_InterpolateThis class is used to interpolate a BsplineCurve
passing through an array of points, with a C2
Continuity if tangency is not requested at the point.
If tangency is requested at the point the continuity
will be C1. If Perodicity is requested the curve will
be closed and the junction will be the first point
given. The curve will than be only C1


Law_Laws
Law_LinearDescribes an linear evolution law.
Law_ListIteratorOfLaws
Law_ListNodeOfLaws
Law_SDescribes an "S" evolution law.
LocalAnalysisThis package gives tools to check the local continuity
between two points situated on two curves or two surfaces.
LocalAnalysis_CurveContinuityThis class gives tools to check local continuity C0
C1 C2 G1 G2 between two points situated on two curves
LocalAnalysis_SurfaceContinuityThis class gives tools to check local continuity C0
C1 C2 G1 G2 between two points situated on two surfaces
LocOpeProvides tools to implement local topological
operations on a shape.
LocOpe_BuilderProvides a basic tool to implement local
topological operations.
LocOpe_BuildShape
LocOpe_BuildWires
LocOpe_CSIntersectorThis class provides the intersection between a set
of axis or a circle and the faces of a shape. The
intersection points are sorted in increasing
parameter along each axis or circle.
LocOpe_CurveShapeIntersectorThis class provides the intersection between an
axis or a circle and the faces of a shape. The
intersection points are sorted in increasing
parameter along the axis.
LocOpe_DataMapIteratorOfDataMapOfShapePnt
LocOpe_DataMapNodeOfDataMapOfShapePnt
LocOpe_DataMapOfShapePnt
LocOpe_DPrismDefines 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_LinearFormDefines a linear form (using Prism from BRepSweep)
with modifications provided for the LinearForm feature.
LocOpe_PipeDefines a pipe (near from Pipe from BRepFill),
with modifications provided for the Pipe feature.
LocOpe_PntFace
LocOpe_PrismDefines a prism (using Prism from BRepSweep)
with modifications provided for the Prism feature.
LocOpe_ProjectedWires
LocOpe_RevolDefines a prism (using Prism from BRepSweep)
with modifications provided for the Prism feature.
LocOpe_RevolutionFormDefines 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_SplitDraftsThis 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_SplitShapeProvides 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_BiIntBiInt is a set of two integers.
MAT2d_CircuitConstructs a circuit on a set of lines.


MAT2d_ConnexionA 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_CutCurveCuts 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_MiniPathMiniPath 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_SketchExplorerSketchExplorer is an iterator on a sketch. A
sketch is a set of contours, each contour is a set
of curves from Geom2d.
MAT2d_Tool2dSet of the methods useful for the MAT's computation.
Tool2d contains the geometry of the bisecting locus.
MAT_ArcAn Arc is associated to each Bisecting of the mat.
MAT_BasicEltA 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_GraphThe 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_ZoneDefinition 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.

MeshAlgoManages different algorithms for triangulation.
(like Delaunay)
MeshAlgo_CircDescribes a 2d circle with a size of only 3
Standard Real numbers instead of gp who needs 7
Standard Real numbers.
MeshAlgo_CircleInspectorThe class to find in the coincidence points
MeshAlgo_CircleToolCreate sort and destroy the circles used in
triangulation.
MeshAlgo_DataMapIteratorOfDataMapOfIntegerCirc
MeshAlgo_DataMapNodeOfDataMapOfIntegerCirc
MeshAlgo_DataMapOfIntegerCirc
MeshAlgo_EdgeDescribes the data structure of a Edge.
MeshAlgo_TriangleDescribes the data structure of a Triangle for
Deleaunay triangulation.
MeshAlgo_VertexDescribes the data structure for a vertex in a
Delaunay triangulation.
MeshDS_DataMapIteratorOfDataMapOfIntegerMapOfInteger
MeshDS_DataMapNodeOfDataMapOfIntegerMapOfInteger
MeshDS_DataMapOfIntegerMapOfInteger
MeshShapeDescribes 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_PolygonPointDescribes a polygon point of an edge.
MeshShape_StdMapNodeOfMapOfCouple
MeshShape_SurfacePointDescribe a point on surface with his UV value and
the coresponding 3d point.
MeshShape_Triangle
MeshShape_Vertex
NLPlate_HGPPConstraintDefine a PinPoint geometric Constraint used to load a Non Linear Plate

NLPlate_HPG0ConstraintDefine a PinPoint G0 Constraint used to load a Non Linear
Plate
NLPlate_HPG0G1ConstraintDefine a PinPoint G0+G1 Constraint used to load a Non Linear
Plate
NLPlate_HPG0G2ConstraintDefine a PinPoint G0+G2 Constraint used to load a Non Linear
Plate
NLPlate_HPG0G3ConstraintDefine a PinPoint G0+G3 Constraint used to load a Non Linear
Plate
NLPlate_HPG1ConstraintDefine a PinPoint (no G0) G1 Constraint used to load a Non
Linear Plate
NLPlate_HPG2ConstraintDefine a PinPoint (no G0) G2 Constraint used to load a Non
Linear Plate
NLPlate_HPG3ConstraintDefine 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_D1Define an order 1 derivatives of a 3d valued
function of a 2d variable

Plate_D2Define an order 2 derivatives of a 3d valued
function of a 2d variable

Plate_D3Define an order 3 derivatives of a 3d valued
function of a 2d variable

Plate_FreeGtoCConstraintDefine a G1, G2 or G3 constraint on the Plate using weaker
constraint than GtoCConstraint

Plate_GlobalTranslationConstraintForce a set of UV points to translate without deformation


Plate_GtoCConstraintDefine a G1, G2 or G3 constraint on the Plate

Plate_HArray1OfPinpointConstraint
Plate_LinearScalarConstraintDefine on or several constraints as linear combination of
the X,Y and Z components of a set of PinPointConstraint

Plate_LinearXYZConstraintDefine on or several constraints as linear combination of
PinPointConstraint unlike the LinearScalarConstraint, usage
of this kind of constraint preserve the X,Y and Z uncoupling.
Plate_LineConstraintConstraint a point to belong to a straight line


Plate_PinpointConstraintDefine a constraint on the Plate

Plate_PlaneConstraintConstraint a point to belong to a Plane

Plate_PlateThis class implement a variationnal spline algorithm able
to define a two variable function satisfying some constraints
and minimizing an energy like criterion.
Plate_SampledCurveConstraintDefine m PinPointConstraint driven by m unknown




Plate_SequenceNodeOfSequenceOfLinearScalarConstraint
Plate_SequenceNodeOfSequenceOfLinearXYZConstraint
Plate_SequenceNodeOfSequenceOfPinpointConstraint
Plate_SequenceOfLinearScalarConstraint
Plate_SequenceOfLinearXYZConstraint
Plate_SequenceOfPinpointConstraint
ShapeAlgo
ShapeAlgo_AlgoContainer
ShapeAlgo_ToolContainer
ShapeAnalysisThis 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_CurveAnalyzing 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_EdgeTool 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_FreeBoundDataThis class is intended to represent free bound and to store
its properties.
ShapeAnalysis_FreeBoundsThis 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_FreeBoundsPropertiesThis 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_GeomAnalyzing tool aimed to work on primitive geometrical objects
ShapeAnalysis_HSequenceOfFreeBounds
ShapeAnalysis_SequenceNodeOfSequenceOfFreeBounds
ShapeAnalysis_SequenceOfFreeBounds
ShapeAnalysis_ShapeContents
ShapeAnalysis_ShapeToleranceTool for computing shape tolerances (minimal, maximal, average),
finding shape with tolerance matching given criteria,
setting or limitating tolerances.
ShapeAnalysis_ShellThis class provides operators to analyze edges orientation
in the shell.
ShapeAnalysis_SurfaceComplements 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_TransferParametersThis tool is used for transferring parameters
from 3d curve of the edge to pcurve and vice versa.
ShapeAnalysis_TransferParametersProjThis 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_WireThis class provides analysis of a wire to be compliant to
CAS.CADE requirements.
ShapeAnalysis_WireOrderThis 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_WireVertexAnalyzes 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
ShapeBuildThis package provides basic building tools for other packages in ShapeHealing.
These tools are rather internal for ShapeHealing .
ShapeBuild_EdgeThis class provides low-level operators for building an edge
3d curve, copying edge with replaced vertices etc.
ShapeBuild_ReShapeRebuilds a Shape by making pre-defined substitutions on some
of its components
ShapeBuild_VertexProvides low-level functions used for constructing vertices
ShapeConstructThis 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_CompBezierCurves2dToBSplineCurve2dConverts a list of connecting Bezier Curves 2d to a
BSplineCurve 2d.
if possible, the continuity of the BSpline will be
increased to more than C0.
ShapeConstruct_CompBezierCurvesToBSplineCurveConverts a list of connecting Bezier Curves to a
BSplineCurve.
if possible, the continuity of the BSpline will be
increased to more than C0.
ShapeConstruct_CurveAdjusts curve to have start and end points at the given
points (currently works on lines and B-Splines only)
ShapeConstruct_MakeTriangulation
ShapeConstruct_ProjectCurveOnSurfaceThis 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.
ShapeCustomThis 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_BSplineRestrictionThis 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_ConvertToBSplineImplement a modification for BRepTools
Modifier algortihm. Converts Surface of
Linear Exctrusion, Revolution and Offset
surfaces into BSpline Surface according to
flags.
ShapeCustom_ConvertToRevolutionImplements a modification for the BRepTools
Modifier algortihm. Converts all elementary
surfaces into surfaces of revolution.
ShapeCustom_CurveConverts BSpline curve to periodic
ShapeCustom_Curve2dConverts curve2d to analytical form with given
precision or simpify curve2d.
ShapeCustom_DirectModificationImplements a modification for the BRepTools
Modifier algortihm. Will redress indirect
surfaces.
ShapeCustom_RestrictionParametersThis class is axuluary tool which contains parameters for
BSplineRestriction class.
ShapeCustom_SurfaceConverts 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_SweptToElementaryImplements a modification for the BRepTools
Modifier algortihm. Converts all elementary
surfaces into surfaces of revolution.
ShapeCustom_TrsfModificationComplements 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.
ShapeExtendThis 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_BasicMsgRegistratorAbstract 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_ComplexCurveDefines a curve which consists of several segments.
Implements basic interface to it.
ShapeExtend_CompositeSurfaceComposite 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_ExplorerThis 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_MsgRegistratorAttaches 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_WireDataThis 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.
ShapeFixThis 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_ComposeShellThis 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_EdgeFixing 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_EdgeConnectMakes vertices to be shared to connect edges,
updates positions and tolerances for shared vertices.
Accepts edges bounded by two vertices each.
ShapeFix_EdgeProjAuxProject 3D point (vertex) on pcurves to find Vertex Parameter
on parametric representation of an edge
ShapeFix_FaceThis 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_FreeBoundsThis 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_IntersectionToolTool for fixing selfintersecting wire
and intersecting wires
ShapeFix_RootRoot 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_ShapeFixing shape in general
ShapeFix_ShapeToleranceModifies tolerances of sub-shapes (vertices, edges, faces)
ShapeFix_ShellFixing orientation of faces in shell
ShapeFix_SolidProvides method to build a solid from a shells and
orients them in order to have a valid solid with finite volume
ShapeFix_SplitCommonVertexTwo 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_SplitToolTool for splitting and cutting edges; includes methods
used in OverlappingTool and IntersectionTool
ShapeFix_WireThis class provides a set of tools for repairing a wire.
ShapeFix_WireframeProvides methods for fixing wireframe of shape
ShapeFix_WireSegmentThis 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_WireVertexFixes 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.
ShapeProcessShape 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_ContextProvides 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_OperatorAbstract Operator class providing a tool to
perform an operation on Context
ShapeProcess_OperLibraryProvides a set of following operators
ShapeProcess_ShapeContextExtends Context to handle shapes
Contains map of shape-shape, and messages
attached to shapes
ShapeProcess_StackItemOfDictionaryOfOperator
ShapeProcess_UOperatorDefines operator as container for static function
OperFunc. This allows user to create new operators
without creation of new classes
ShapeProcessAPI_ApplySequenceApplies one of the sequence read from resource file.
ShapeUpgradeThis 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_ClosedFaceDivideDivides 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_ConvertCurve2dToBezierConverts/splits a 2d curve to a list of beziers
ShapeUpgrade_ConvertCurve3dToBezierConverts/splits a 3d curve of any type to a list of beziers
ShapeUpgrade_ConvertSurfaceToBezierBasisConverts 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_FaceDivideDivides 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_FaceDivideAreaDivides face by max area criterium.
ShapeUpgrade_FixSmallBezierCurves
ShapeUpgrade_FixSmallCurves
ShapeUpgrade_RemoveInternalWiresRemoves all internal wires having area less than specified min area
ShapeUpgrade_RemoveLocationsRemoves all locations sub-shapes of specified shape
ShapeUpgrade_ShapeConvertToBezierAPI 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_ShapeDivideDivides a all faces in shell with given criteria Shell.
ShapeUpgrade_ShapeDivideAngleSplits 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_ShapeDivideAreaDivides faces from sprcified shape by max area criterium.
ShapeUpgrade_ShapeDivideClosedDivides all closed faces in the shape. Class
ShapeUpgrade_ClosedFaceDivide is used as divide tool.
ShapeUpgrade_ShapeDivideClosedEdges
ShapeUpgrade_ShapeDivideContinuity
ShapeUpgrade_ShellSewingThis 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_SplitCurveSplits a curve with a criterion.
ShapeUpgrade_SplitCurve2dSplits a 2d curve with a criterion.
ShapeUpgrade_SplitCurve2dContinuityCorrects/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_SplitCurve3dSplits a 3d curve with a criterion.
ShapeUpgrade_SplitCurve3dContinuityCorrects/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_SplitSurfaceSplits a Surface with a criterion.
ShapeUpgrade_SplitSurfaceAngleSplits a surfaces of revolution, cylindrical, toroidal,
conical, spherical so that each resulting segment covers
not more than defined number of degrees.
ShapeUpgrade_SplitSurfaceAreaSplit surface in the parametric space
in according specified number of splits on the
ShapeUpgrade_SplitSurfaceContinuitySplits 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_ToolTool is a root class for splitting classes
Provides context for recording changes, basic
precision value and limit (minimal and maximal)
values for tolerances
ShapeUpgrade_WireDivideDivides 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_NumShapeGives a simple indexed representation of a
Directing Edge topology.
Sweep_NumShapeIteratorThis class provides iteration services required by
the Swept Primitives for a Directing NumShape
Line.

Sweep_NumShapeToolThis 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_Intersection3dTemplate 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_SolidExplorerProvide an exploration of a BRep Shape for the
classification.
TopCnx_EdgeFaceTransitionTheEdgeFaceTransition is an algorithm to compute
the cumulated transition for interferences on an
edge.
TopOpeBRepThis 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_DSFillerProvides 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_EdgesFillerFills a TopOpeBRepDS_DataStructure with Edge/Edge
instersection data described by TopOpeBRep_EdgesIntersector.
TopOpeBRep_EdgesIntersector
TopOpeBRep_FaceEdgeFiller
TopOpeBRep_FaceEdgeIntersector
TopOpeBRep_FacesFillerFills 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_GeomToolProvide 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_PointGeomToolProvide services needed by the Fillers
TopOpeBRep_SequenceNodeOfSequenceOfPoint2d
TopOpeBRep_SequenceOfPoint2d
TopOpeBRep_ShapeIntersectorIntersect 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_ShapeIntersector2dIntersect 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_ShapeScannerFind, 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_Area2dBuilderThe 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_Area3dBuilderThe 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_AreaBuilderThe 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_BlockIteratorIterator on the elements of a block.
TopOpeBRepBuild_BuilderThe 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_Builder1Extension of the class TopOpeBRepBuild_Builder dedicated
to avoid bugs in "Rebuilding Result" algorithm for the case of SOLID/SOLID Boolean Operations
TopOpeBRepBuild_BuilderON
TopOpeBRepBuild_CompositeClassifierClassify 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_FaceAreaBuilderThe 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_HBuilderThe 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_LoopLoop 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_LoopClassifierClassify loops in order to build Areas
TopOpeBRepBuild_LoopSet
TopOpeBRepBuild_Pave
TopOpeBRepBuild_PaveClassifierThis 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_PaveSetClass providing an exploration of a set of vertices to build edges.
It is similar to LoopSet from TopOpeBRepBuild where Loop is Pave.
TopOpeBRepBuild_ShapeListOfShapeRepresent shape + a list of shape
TopOpeBRepBuild_ShapeSetAuxiliary 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_ShellFaceClassifierClassify faces and shells.
shapes are Shells, Elements are Faces.
TopOpeBRepBuild_ShellFaceSetBound 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_ShellToSolidThis class builds solids from a set of shells SSh and a solid F.
TopOpeBRepBuild_SolidAreaBuilderThe 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_ToolsAuxiliary methods used in TopOpeBRepBuild_Builder1 class
TopOpeBRepBuild_Tools2d
TopOpeBRepBuild_VertexInfo
TopOpeBRepBuild_WireEdgeClassifierClassify edges and wires.
shapes are Wires, Element are Edge.
TopOpeBRepBuild_WireEdgeSetBound 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_WireToFaceThis 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)
TopOpeBRepDSThis package provides services used by the TopOpeBRepBuild
package performing topological operations on the BRep
data structure.
TopOpeBRepDS_Array1OfDataMapOfIntegerListOfInterference
TopOpeBRepDS_Association
TopOpeBRepDS_BuildToolProvides a Tool to build topologies. Used to
instantiate the Builder algorithm.
TopOpeBRepDS_CheckTool verifing integrity and structure of DS
TopOpeBRepDS_CurveA Geom point and a tolerance.
TopOpeBRepDS_CurveData
TopOpeBRepDS_CurveExplorer
TopOpeBRepDS_CurveIterator
TopOpeBRepDS_CurvePointInterferenceAn 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_DataStructureThe 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_Edge3dInterferenceToolTool computing edge / face complex transition,
Interferences of edge reference are given by
I = (T on face, G = point or vertex, S = edge)
TopOpeBRepDS_EdgeInterferenceToolTool computing complex transition on Edge.
TopOpeBRepDS_EdgeVertexInterferenceAn interference with a parameter.
TopOpeBRepDS_EIREdgeInterferenceReducer
TopOpeBRepDS_Explorer
TopOpeBRepDS_FaceEdgeInterference
TopOpeBRepDS_FaceInterferenceToolTool computing complex transition on Face.
TopOpeBRepDS_Filter
TopOpeBRepDS_FIRFaceInterferenceReducer
TopOpeBRepDS_GapFiller
TopOpeBRepDS_GapTool
TopOpeBRepDS_GeometryDataMother-class of SurfaceData, CurveData, PointData
TopOpeBRepDS_HArray1OfDataMapOfIntegerListOfInterference
TopOpeBRepDS_HDataStructure
TopOpeBRepDS_IndexedDataMapNodeOfIndexedDataMapOfShapeWithState
TopOpeBRepDS_IndexedDataMapNodeOfIndexedDataMapOfVertexPoint
TopOpeBRepDS_IndexedDataMapNodeOfMapOfShapeData
TopOpeBRepDS_IndexedDataMapOfShapeWithState
TopOpeBRepDS_IndexedDataMapOfVertexPoint
TopOpeBRepDS_InterferenceAn 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_InterferenceIteratorIterate 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_ListOfShapeOn1StateRepresent a list of shape
TopOpeBRepDS_MapOfCurve
TopOpeBRepDS_MapOfIntegerShapeData
TopOpeBRepDS_MapOfPoint
TopOpeBRepDS_MapOfShapeData
TopOpeBRepDS_MapOfSurface
TopOpeBRepDS_Marker
TopOpeBRepDS_PointA Geom point and a tolerance.
TopOpeBRepDS_PointData
TopOpeBRepDS_PointExplorer
TopOpeBRepDS_PointIterator
TopOpeBRepDS_ReducerReduce interferences of a data structure (HDS)
used in topological operations.
TopOpeBRepDS_ShapeData
TopOpeBRepDS_ShapeShapeInterference
TopOpeBRepDS_ShapeSurface
TopOpeBRepDS_ShapeWithState
TopOpeBRepDS_SolidSurfaceInterference
TopOpeBRepDS_SurfaceA Geom poimt and a tolerance.
TopOpeBRepDS_SurfaceCurveInterferenceInterference with a 2d curve
TopOpeBRepDS_SurfaceData
TopOpeBRepDS_SurfaceExplorer
TopOpeBRepDS_SurfaceIterator
TopOpeBRepDS_TKI
TopOpeBRepDS_TOOL
TopOpeBRepDS_Transition
TopOpeBRepToolThis package provides services used by the TopOpeBRep
package performing topological operations on the BRep
data structure.

TopOpeBRepTool_AncestorsToolDescribes 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_CORRISOFref 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_FuseEdgesThis class can detect vertices in a face that can
be considered useless and then perform the fuse of
the edges and remove the useless vertices. By
useles vertices, we mean :
* 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_PurgeInternalEdgesRemove 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_CurveTransitionThis 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_SurfaceTransitionThis 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

Generated on Mon Aug 25 13:40:29 2008 for OpenCASCADE by  doxygen 1.4.1