OpenCascade.js
API ReferenceModelingAlgorithmsTKBool

BRepFill

OCCT package BRepFill: BRepFill, BRepFill_ACRLaw, BRepFill_AdvancedEvolved, BRepFill_ApproxSeewing, and 29 more bound classes.

BRepFill

Constructors(1)

Static methods(5)

  • Face(Edge1: TopoDS_Edge, Edge2: TopoDS_Edge): TopoDS_Face

    Computes a ruled surface between two edges.

    Parameters (2)
    • Edge1
    • Edge2
  • Shell(Wire1: TopoDS_Wire, Wire2: TopoDS_Wire): TopoDS_Shell

    Computes a ruled surface between two wires. The wires must have the same number of edges.

    Parameters (2)
    • Wire1
    • Wire2
  • Axe(Spine: TopoDS_Shape, Profile: TopoDS_Wire, AxeProf: gp_Ax3, ProfOnSpine: boolean, Tol: number): { ProfOnSpine: boolean }

    Computes <AxeProf> as Follow. <Location> is the Position of the nearest vertex V of <Profile> to <Spine>.<XDirection> is confused with the tangent to <Spine> at the projected point of V on the Spine. <Direction> is normal to <Spine>. <Spine> is a plane wire or a plane face.

    Parameters (5)
    • Spine
    • Profile
    • AxeProf —
      Mutated in place; read the updated value from this argument after the call.
    • ProfOnSpine
    • Tol
    Returns

    A result object with fields:

    • ProfOnSpine: updated value from the call.
  • ComputeACR(wire: TopoDS_Wire, ACR: NCollection_Array1_double): void

    Compute ACR on a wire.

    Parameters (2)
    • wire
    • ACR —
      Mutated in place; read the updated value from this argument after the call.
  • InsertACR(wire: TopoDS_Wire, ACRcuts: NCollection_Array1_double, prec: number): TopoDS_Wire

    Insert ACR on a wire.

    Parameters (3)
    • wire
    • ACRcuts
    • prec

BRepFill_AdvancedEvolved

Constructs an evolved volume from a spine (wire or face) and a profile (wire).

Constructors(1)

Instance methods(5)

  • Perform(theSpine: TopoDS_Wire, theProfile: TopoDS_Wire, theTolerance: number, theSolidReq?: boolean): void
    Parameters (4)
    • theSpine
    • theProfile
    • theTolerance
    • theSolidReq
  • IsDone(theErrorCode?: number): boolean
    Parameters (1)
    • theErrorCode
  • Shape(): TopoDS_Shape

    returns the resulting shape.

  • SetTemporaryDirectory(thePath: string): void

    Sets directory where the debug shapes will be saved.

    Parameters (1)
    • thePath
  • SetParallelMode(theVal: boolean): void

    Sets/Unsets computation in parallel mode.

    Parameters (1)
    • theVal

BRepFill_ApproxSeewing

Evaluate the 3dCurve and the PCurves described in a MultiLine from BRepFill. The parametrization of those curves is not imposed by the Bissectrice. The parametrization is given approximately by the abscissa of the curve3d.

Constructors(2)

Instance methods(5)

BRepFill_CompatibleWires

Constructs a sequence of Wires (with good orientation and origin) agreed each other so that the surface passing through these sections is not twisted.

Constructors(2)

Instance methods(10)

BRepFill_ComputeCLine

Constructors(2)

Instance methods(13)

  • Perform(Line: BRepFill_MultiLine): void

    runs the algorithm after having initialized the fields.

    Parameters (1)
    • Line
  • SetDegrees(degreemin: number, degreemax: number): void

    changes the degrees of the approximation.

    Parameters (2)
    • degreemin
    • degreemax
  • SetTolerances(Tolerance3d: number, Tolerance2d: number): void

    Changes the tolerances of the approximation.

    Parameters (2)
    • Tolerance3d
    • Tolerance2d
  • SetConstraints(FirstC: AppParCurves_Constraint, LastC: AppParCurves_Constraint): void

    Changes the constraints of the approximation.

    Parameters (2)
    • FirstC
    • LastC
  • SetMaxSegments(theMaxSegments: number): void

    Changes the max number of segments, which is allowed for cutting.

    Parameters (1)
    • theMaxSegments
  • SetInvOrder(theInvOrder: boolean): void

    Set inverse order of degree selection: if theInvOrdr = true, current degree is chosen by inverse order - from maxdegree to mindegree. By default inverse order is used.

    Parameters (1)
    • theInvOrder
  • SetHangChecking(theHangChecking: boolean): void

    Set value of hang checking flag if this flag = true, possible hang of algorithm is checked and algorithm is forced to stop. By default hang checking is used.

    Parameters (1)
    • theHangChecking
  • IsAllApproximated(): boolean

    returns False if at a moment of the approximation, the status NoApproximation has been sent by the user when more points were needed.

  • IsToleranceReached(): boolean

    returns False if the status NoPointsAdded has been sent.

  • Error(Index: number, tol3d: number, tol2d: number): { tol3d: number; tol2d: number }

    returns the tolerances 2d and 3d of the <Index> MultiCurve.

    Parameters (3)
    • Index
    • tol3d
    • tol2d
    Returns

    A result object with fields:

    • tol3d: updated value from the call.
    • tol2d: updated value from the call.
  • NbMultiCurves(): number

    Returns the number of MultiCurve doing the approximation of the MultiLine.

  • Value(Index?: number): AppParCurves_MultiCurve

    returns the approximation MultiCurve of range <Index>.

    Parameters (1)
    • Index
  • Parameters(Index: number, firstp: number, lastp: number): { firstp: number; lastp: number }
    Parameters (3)
    • Index
    • firstp
    • lastp

BRepFill_CurveConstraint

GeomPlate_CurveConstraintStandard_Transient

same as CurveConstraint from GeomPlate with BRepAdaptor_Surface instead of GeomAdaptor_Surface

Constructors(2)

  • constructor(Boundary: Adaptor3d_Curve, Tang: number, NPt?: number, TolDist?: number): BRepFill_CurveConstraint
    Parameters (4)
    • Boundary
    • Tang
    • NPt
    • TolDist
  • constructor(Boundary: Adaptor3d_CurveOnSurface, Order: number, NPt?: number, TolDist?: number, TolAng?: number, TolCurv?: number): BRepFill_CurveConstraint

    Create a constraint Order is the order of the constraint. The possible values for order are -1,0,1,2. Order i means constraints Gi Npt is the number of points associated with the constraint. TolDist is the maximum error to satisfy for G0 constraints TolAng is the maximum error to satisfy for G1 constraints TolCurv is the maximum error to satisfy for G2 constraints These errors can be replaced by laws of criterion.

    Parameters (6)
    • Boundary
    • Order
    • NPt
    • TolDist
    • TolAng
    • TolCurv

Static methods(2)

Instance methods(1)

BRepFill_Draft

Constructors(1)

Instance methods(9)

BRepFill_Evolved

Constructs an evolved volume from a spine (wire or face) and a profile ( wire).

Constructors(3)

Instance methods(8)

BRepFill_Filling

N-Side Filling This algorithm avoids to build a face from:

  • a set of edges defining the bounds of the face and some constraints the surface support has to satisfy
  • a set of edges and points defining some constraints the support surface has to satisfy
  • an initial surface to deform for satisfying the constraints
  • a set of parameters to control the constraints.
    The support surface of the face is computed by deformation of the initial surface in order to satisfy the given constraints. The set of bounding edges defines the wire of the face.
    If no initial surface is given, the algorithm computes it automatically. If the set of edges is not connected (Free constraint) missing edges are automatically computed.
    Limitations:
  • If some constraints are not compatible The algorithm does not take them into account. So the constraints will not be satisfied in an area containing the incompatibilities.
  • The constraints defining the bound of the face have to be entered in order to have a continuous wire.
    Other Applications:
  • Deformation of a face to satisfy internal constraints
  • Deformation of a face to improve Gi continuity with connected faces

Constructors(1)

  • constructor(Degree?: number, NbPtsOnCur?: number, NbIter?: number, Anisotropie?: boolean, Tol2d?: number, Tol3d?: number, TolAng?: number, TolCurv?: number, MaxDeg?: number, MaxSegments?: number): BRepFill_Filling

    Constructor.

    Parameters (10)
    • Degree
    • NbPtsOnCur
    • NbIter
    • Anisotropie
    • Tol2d
    • Tol3d
    • TolAng
    • TolCurv
    • MaxDeg
    • MaxSegments

Instance methods(19)

  • SetConstrParam(Tol2d?: number, Tol3d?: number, TolAng?: number, TolCurv?: number): void

    Sets the values of Tolerances used to control the constraint. Tol2d: Tol3d: it is the maximum distance allowed between the support surface and the constraints TolAng: it is the maximum angle allowed between the normal of the surface and the constraints TolCurv: it is the maximum difference of curvature allowed between the surface and the constraint.

    Parameters (4)
    • Tol2d
    • Tol3d
    • TolAng
    • TolCurv
  • SetResolParam(Degree?: number, NbPtsOnCur?: number, NbIter?: number, Anisotropie?: boolean): void

    Sets the parameters used for resolution. The default values of these parameters have been chosen for a good ratio quality/performance. Degree: it is the order of energy criterion to minimize for computing the deformation of the surface. The default value is 3 The recommended value is i+2 where i is the maximum order of the constraints. NbPtsOnCur: it is the average number of points for discretisation of the edges. NbIter: it is the maximum number of iterations of the process. For each iteration the number of discretisation points is increased. Anisotropie:

    Parameters (4)
    • Degree
    • NbPtsOnCur
    • NbIter
    • Anisotropie
  • SetApproxParam(MaxDeg?: number, MaxSegments?: number): void

    Sets the parameters used for approximation of the surface.

    Parameters (2)
    • MaxDeg
    • MaxSegments
  • LoadInitSurface(aFace: TopoDS_Face): void

    Loads the initial Surface The initial surface must have orthogonal local coordinates, i.e. partial derivatives dS/du and dS/dv must be orthogonal at each point of surface. If this condition breaks, distortions of resulting surface are possible.

    Parameters (1)
    • aFace
  • Add(Point: gp_Pnt): number

    Adds a punctual constraint.

    Parameters (1)
    • Point
  • Add(Support: TopoDS_Face, Order: GeomAbs_Shape): number

    Adds a free constraint on a face. The corresponding edge has to be automatically recomputed. It is always a bound.

    Parameters (2)
    • Support
    • Order
  • Add(anEdge: TopoDS_Edge, Order: GeomAbs_Shape, IsBound: boolean): number

    Adds a new constraint which also defines an edge of the wire of the face Order: Order of the constraint: GeomAbs_C0 : the surface has to pass by 3D representation of the edge GeomAbs_G1 : the surface has to pass by 3D representation of the edge and to respect tangency with the first face of the edge GeomAbs_G2 : the surface has to pass by 3D representation of the edge and to respect tangency and curvature with the first face of the edge.

    Parameters (3)
    • anEdge
    • Order
    • IsBound
  • Add(anEdge: TopoDS_Edge, Support: TopoDS_Face, Order: GeomAbs_Shape, IsBound: boolean): number

    Adds a new constraint which also defines an edge of the wire of the face Order: Order of the constraint: GeomAbs_C0 : the surface has to pass by 3D representation of the edge GeomAbs_G1 : the surface has to pass by 3D representation of the edge and to respect tangency with the given face GeomAbs_G2 : the surface has to pass by 3D representation of the edge and to respect tangency and curvature with the given face.

    Parameters (4)
    • anEdge
    • Support
    • Order
    • IsBound
  • Add(U: number, V: number, Support: TopoDS_Face, Order: GeomAbs_Shape): number

    Adds a punctual constraint.

    Parameters (4)
    • U
    • V
    • Support
    • Order
  • Build(): void

    Builds the resulting faces.

  • IsDone(): boolean
  • Face(): TopoDS_Face
  • Generated(S: TopoDS_Shape): NCollection_List_TopoDS_Shape

    Returns the list of shapes generated from the shape .

    Parameters (1)
    • S
  • G0Error(): number
  • G0Error(Index: number): number
    Parameters (1)
    • Index
  • G1Error(): number
  • G1Error(Index: number): number
    Parameters (1)
    • Index
  • G2Error(): number
  • G2Error(Index: number): number
    Parameters (1)
    • Index

BRepFill_Generator

Compute a topological surface (a shell) using generating wires. The face of the shell will be ruled surfaces passing by the wires. The wires must have the same number of edges.

Constructors(1)

Instance methods(9)

BRepFill_LocationLaw

Standard_Transient

Location Law on a Wire.

Constructors(1)

Static methods(2)

Instance methods(19)

  • GetStatus(): GeomFill_PipeError

    Return a error status, if the status is not PipeOk then it exist a parameter tlike the law is not valuable for t.

  • TransformInG0Law(): void

    Apply a linear transformation on each law, to have continuity of the global law between the edges.

  • TransformInCompatibleLaw(AngularTolerance: number): void

    Apply a linear transformation on each law, to reduce the dicontinuities of law at one rotation.

    Parameters (1)
    • AngularTolerance
  • DeleteTransform(): void
  • NbHoles(Tol?: number): number
    Parameters (1)
    • Tol
  • Holes(Interval: NCollection_Array1_int): void
    Parameters (1)
    • Interval
  • NbLaw(): number

    Return the number of elementary Law.

  • Law(Index: number): GeomFill_LocationLaw

    Return the elementary Law of rank <Index> <Index> have to be in [1, NbLaw()].

    Parameters (1)
    • Index
  • Wire(): TopoDS_Wire

    return the path

  • Edge(Index: number): TopoDS_Edge

    Return the Edge of rank <Index> in the path <Index> have to be in [1, NbLaw()].

    Parameters (1)
    • Index
  • Vertex(Index: number): TopoDS_Vertex

    Return the vertex of rank <Index> in the path <Index> have to be in [0, NbLaw()].

    Parameters (1)
    • Index
  • PerformVertex(Index: number, InputVertex: TopoDS_Vertex, TolMin: number, OutputVertex: TopoDS_Vertex, Location: number): void

    Compute <OutputVertex> like a transformation of <InputVertex> the transformation is given by evaluation of the location law in the vertex of rank <Index>. <Location> is used to manage discontinuities:

    • -1 : The law before the vertex is used.
    • 1 : The law after the vertex is used.
    • 0 : Average of the both laws is used.
    Parameters (5)
    • Index
    • InputVertex
    • TolMin
    • OutputVertex —
      Mutated in place; read the updated value from this argument after the call.
    • Location
  • CurvilinearBounds(Index: number, First: number, Last: number): { First: number; Last: number }

    Return the Curvilinear Bounds of the <Index> Law.

    Parameters (3)
    • Index
    • First
    • Last
    Returns

    A result object with fields:

    • First: updated value from the call.
    • Last: updated value from the call.
  • IsClosed(): boolean
  • IsG1(Index: number, SpatialTolerance?: number, AngularTolerance?: number): number

    Compute the Law's continuity between 2 edges of the path The result can be : -1 : Case Not connex 0 : It is connex (G0) 1 : It is tangent (G1).

    Parameters (3)
    • Index
    • SpatialTolerance
    • AngularTolerance
  • D0(Abscissa: number, Section: TopoDS_Shape): void

    Apply the Law to a shape, for a given Curvilinear abscissa.

    Parameters (2)
    • Abscissa
    • Section —
      Mutated in place; read the updated value from this argument after the call.
  • Parameter(Abscissa: number, Index: number, Param: number): { Index: number; Param: number }

    Find the index Law and the parameter, for a given Curvilinear abscissa.

    Parameters (3)
    • Abscissa
    • Index
    • Param
    Returns

    A result object with fields:

    • Index: updated value from the call.
    • Param: updated value from the call.
  • Abscissa(Index: number, Param: number): number

    Return the curvilinear abscissa corresponding to a point of the path, defined by <Index> of Edge and a parameter on the edge.

    Parameters (2)
    • Index
    • Param
  • DynamicType(): Standard_Type

BRepFill_MultiLine

AppCont_Function

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. These 3 curves will have the same parametrization as the Bissectrice. This class is to be sent to an approximation routine.

Constructors(2)

Instance methods(11)

  • IsParticularCase(): boolean

    Search if the Projection of the Bissectrice on the faces needs an approximation or not. Returns true if the approximation is not needed.

  • Continuity(): GeomAbs_Shape

    Returns the continuity between the two faces seShape from GeomAbsparated by myBis.

  • Curves(): { Curve: Geom_Curve; PCurve1: Geom2d_Curve; PCurve2: Geom2d_Curve; [Symbol.dispose](): void }

    raises if IsParticularCase is <False>.

    Returns

    A result object with fields:

    • Curve: owned by the returned envelope.
    • PCurve1: owned by the returned envelope.
    • PCurve2: owned by the returned envelope.
      Dispose the returned envelope to release owned Handle fields.
  • FirstParameter(): number

    returns the first parameter of the Bissectrice.

  • LastParameter(): number

    returns the last parameter of the Bissectrice.

  • Value(U: number): gp_Pnt

    Returns the current point on the 3d curve.

    Parameters (1)
    • U
  • Value(theU: number, thePnt2d: NCollection_Array1_gp_Pnt2d, thePnt: NCollection_Array1_gp_Pnt): boolean

    Returns the point at parameter <theU>.

    Parameters (3)
    • theU
    • thePnt2d —
      Mutated in place; read the updated value from this argument after the call.
    • thePnt —
      Mutated in place; read the updated value from this argument after the call.
  • ValueOnF1(U: number): gp_Pnt2d

    returns the current point on the PCurve of the first face

    Parameters (1)
    • U
  • ValueOnF2(U: number): gp_Pnt2d

    returns the current point on the PCurve of the first face

    Parameters (1)
    • U
  • Value3dOnF1OnF2(U: number, P3d: gp_Pnt, PF1: gp_Pnt2d, PF2: gp_Pnt2d): void
    Parameters (4)
    • U
    • P3d
    • PF1
    • PF2
  • D1(theU: number, theVec2d: NCollection_Array1_gp_Vec2d, theVec: NCollection_Array1_gp_Vec): boolean

    Returns the derivative at parameter <theU>.

    Parameters (3)
    • theU
    • theVec2d —
      Mutated in place; read the updated value from this argument after the call.
    • theVec —
      Mutated in place; read the updated value from this argument after the call.

BRepFill_NSections

BRepFill_SectionLawStandard_Transient

Build Section Law, with N Sections.

Constructors(2)

Static methods(2)

Instance methods(8)

BRepFill_OffsetAncestors

this class is used to find the generating shapes of an OffsetWire.

Constructors(2)

Instance methods(4)

BRepFill_OffsetWire

Constructs a Offset Wire to a spine (wire or face). Offset direction will be to outer region in case of positive offset value and to inner region in case of negative offset value. Inner/Outer region for open wire is defined by the following rule: when we go along the wire (taking into account of edges orientation) then outer region will be on the right side, inner region will be on the left side. In case of closed wire, inner region will always be inside the wire (at that, edges orientation is not taken into account). The Wire or the Face must be planar and oriented correctly.

Constructors(2)

Instance methods(8)

BRepFill_Pipe

Create a shape by sweeping a shape (the profile) along a wire (the spine).
For each edge or vertex from the spine the user may ask for the shape generated from each subshape of the profile.

Constructors(2)

Instance methods(12)

BRepFill_PipeShell

Standard_Transient

Computes a topological shell using some wires (spines and profiles) and displacement option Perform general sweeping construction.

Constructors(1)

Static methods(2)

Instance methods(31)

  • Set(Frenet: boolean): void

    Set an Frenet or an CorrectedFrenet trihedron to perform the sweeping.

    Parameters (1)
    • Frenet
  • Set(Axe: gp_Ax2): void

    Set an fixed trihedron to perform the sweeping all sections will be parallel.

    Parameters (1)
    • Axe
  • Set(BiNormal: gp_Dir): void

    Set an fixed BiNormal direction to perform the sweeping.

    Parameters (1)
    • BiNormal
  • Set(SpineSupport: TopoDS_Shape): boolean

    Set support to the spine to define the BiNormal at the spine, like the normal the surfaces. Warning: To be effective, Each edge of the <spine> must have an representation on one face of<SpineSupport>.

    Parameters (1)
    • SpineSupport
  • Set(AuxiliarySpine: TopoDS_Wire, CurvilinearEquivalence: boolean, KeepContact: BRepFill_TypeOfContact): void

    Set an auxiliary spine to define the Normal For each Point of the Spine P, an Point Q is evaluated on <AuxiliarySpine> If <CurvilinearEquivalence> Q split <AuxiliarySpine> with the same length ratio than P split <Spline>. Else the plan define by P and the tangent to the <Spine> intersect <AuxiliarySpine> in Q. If <KeepContact> equals BRepFill_NoContact: The Normal is defined by the vector PQ.
    If <KeepContact> equals BRepFill_Contact: The Normal is defined to achieve that the sweeped section is in contact to the auxiliarySpine. The width of section is constant all along the path. In other words, the auxiliary spine lies on the swept surface, but not necessarily is a boundary of this surface.
    However, the auxiliary spine has to be close enough to the main spine to provide intersection with any section all along the path.
    If <KeepContact> equals BRepFill_ContactOnBorder: The auxiliary spine becomes a boundary of the swept surface and the width of section varies along the path.

    Parameters (3)
    • AuxiliarySpine
    • CurvilinearEquivalence
    • KeepContact
  • SetDiscrete(): void

    Set a Discrete trihedron to perform the sweeping.

  • SetMaxDegree(NewMaxDegree: number): void

    Define the maximum V degree of resulting surface.

    Parameters (1)
    • NewMaxDegree
  • SetMaxSegments(NewMaxSegments: number): void

    Define the maximum number of spans in V-direction on resulting surface.

    Parameters (1)
    • NewMaxSegments
  • SetForceApproxC1(ForceApproxC1: boolean): void

    Set the flag that indicates attempt to approximate a C1-continuous surface if a swept surface proved to be C0. Give section to sweep. Possibilities are:

    • Give one or several profile
    • Give one profile and an homotetic law.
    • Automatic compute of correspondence between profile, and section on the sweeped shape
    • correspondence between profile, and section on the sweeped shape defined by a vertex of the spine
    Parameters (1)
    • ForceApproxC1
  • SetIsBuildHistory(theIsBuildHistory: boolean): void

    Sets the build history flag. If set to True, the pipe shell will store the history of the sections and the spine, which can be used for further modifications or analysis.

    Parameters (1)
    • theIsBuildHistory
  • IsBuildHistory(): boolean

    Returns the build history flag. If True, the pipe shell stores the history of the sections and the spine.

  • Add(Profile: TopoDS_Shape, WithContact: boolean, WithCorrection: boolean): void

    Set an section. The correspondence with the spine, will be automatically performed.

    Parameters (3)
    • Profile
    • WithContact
    • WithCorrection
  • Add(Profile: TopoDS_Shape, Location: TopoDS_Vertex, WithContact: boolean, WithCorrection: boolean): void

    Set an section. The correspondence with the spine, is given by Location.

    Parameters (4)
    • Profile
    • Location
    • WithContact
    • WithCorrection
  • SetLaw(Profile: TopoDS_Shape, L: Law_Function, WithContact: boolean, WithCorrection: boolean): void

    Set an section and an homotetic law. The homotetie's centers is given by point on the <Spine>.

    Parameters (4)
    • Profile
    • L
    • WithContact
    • WithCorrection
  • SetLaw(Profile: TopoDS_Shape, L: Law_Function, Location: TopoDS_Vertex, WithContact: boolean, WithCorrection: boolean): void

    Set an section and an homotetic law. The homotetie center is given by point on the <Spine>.

    Parameters (5)
    • Profile
    • L
    • Location
    • WithContact
    • WithCorrection
  • DeleteProfile(Profile: TopoDS_Shape): void

    Delete an section.

    Parameters (1)
    • Profile
  • IsReady(): boolean

    Say if <me> is ready to build the shape return False if <me> do not have section definition.

  • GetStatus(): GeomFill_PipeError

    Get a status, when Simulate or Build failed.

  • SetTolerance(Tol3d?: number, BoundTol?: number, TolAngular?: number): void
    Parameters (3)
    • Tol3d
    • BoundTol
    • TolAngular
  • SetTransition(Mode?: BRepFill_TransitionStyle, Angmin?: number, Angmax?: number): void

    Set the Transition Mode to manage discontinuities on the sweep.

    Parameters (3)
    • Mode
    • Angmin
    • Angmax
  • Simulate(NumberOfSection: number, Sections: NCollection_List_TopoDS_Shape): void

    Perform simulation of the sweep: Some Section are returned.

    Parameters (2)
    • NumberOfSection
    • Sections —
      Mutated in place; read the updated value from this argument after the call.
  • Build(): boolean

    Builds the resulting shape (redefined from MakeShape).

  • MakeSolid(): boolean

    Transform the sweeping Shell in Solid. If the section are not closed returns False.

  • Shape(): TopoDS_Shape

    Returns the result Shape.

  • ErrorOnSurface(): number
  • FirstShape(): TopoDS_Shape

    Returns the TopoDS Shape of the bottom of the sweep.

  • LastShape(): TopoDS_Shape

    Returns the TopoDS Shape of the top of the sweep.

  • Profiles(theProfiles: NCollection_List_TopoDS_Shape): void

    Returns the list of original profiles.

    Parameters (1)
    • theProfiles —
      Mutated in place; read the updated value from this argument after the call.
  • Spine(): TopoDS_Wire

    Returns the spine.

  • Generated(S: TopoDS_Shape, L: NCollection_List_TopoDS_Shape): void

    Returns the list of shapes generated from the shape .

    Parameters (2)
    • S
    • L —
      Mutated in place; read the updated value from this argument after the call.
  • DynamicType(): Standard_Type

BRepFill_Section

To store section definition.

Constructors(2)

Instance methods(9)

BRepFill_SectionLaw

Standard_Transient

Build Section Law, with an Vertex, or an Wire.

Static methods(2)

Instance methods(16)

BRepFill_SectionPlacement

Place a shape in a local axis coordinate.

Constructors(2)

Instance methods(2)

BRepFill_ShapeLaw

BRepFill_SectionLawStandard_Transient

Build Section Law, with an Vertex, or an Wire.

Constructors(3)

Static methods(2)

Instance methods(9)

BRepFill_Sweep

Topological Sweep Algorithm Computes an Sweep shell using a generating wire, an SectionLaw and an LocationLaw.

Constructors(1)

Instance methods(12)

BRepFill_ThruSectionErrorStatus

Properties(7)

BRepFill_TrimEdgeTool

Geometric Tool using to construct Offset Wires.

Constructors(2)

Instance methods(3)

BRepFill_TrimShellCorner

Trims sets of faces in the corner to make proper parts of pipe.

Constructors(1)

  • constructor(theFaces: NCollection_HArray2_TopoDS_Shape, theTransition: BRepFill_TransitionStyle, theAxeOfBisPlane: gp_Ax2, theIntPointCrossDir: gp_Vec): BRepFill_TrimShellCorner

    Constructor: takes faces to intersect, type of transition (it can be RightCorner or RoundCorner) and axis of bisector plane theIntersectPointCrossDirection : prev path direction at the origin point of theAxeOfBisPlane cross next path direction at the origin point of theAxeOfBisPlane. used when EE has more than one vertices.

    Parameters (4)
    • theFaces
    • theTransition
    • theAxeOfBisPlane
    • theIntPointCrossDir

Instance methods(7)

BRepAlgo

OCCT package BRepAlgo: BRepAlgo, BRepAlgo_AsDes, BRepAlgo_FaceRestrictor, BRepAlgo_Image, and 2 more bound classes.

BRepProj

OCCT package BRepProj: BRepProj_Projection.