Curve3D — Analytic Types

These members expose type-specific properties of analytic curves (circle, ellipse, hyperbola, parabola, line) plus B-spline/Bézier pole/knot/weight accessors. They are valid only when the underlying curve is of the matching kind — accessing them on a mismatched curve type returns zero/nil silently. See the main Curve3D page for construction methods, evaluation, and operations.

Topics

BSpline Queries · BSpline Knot Splitting (v0.40.0) · Geom_Circle Properties (v0.108.0) · Geom_Ellipse Properties (v0.108.0) · Geom_Hyperbola Properties (v0.108.0) · Geom_Parabola Properties (v0.108.0) · Geom_Line Properties (v0.108.0) · Bezier Curve deep method completion (v0.125.0) · Bezier 3D completions (v0.126.0) · BSpline completions (v0.127.0)

BSpline Queries

`poleCount`

Number of poles (control points), or nil if the curve is not a B-spline or Bézier.

public var poleCount: Int? { get }

Returns: Pole count, or nil when the curve cannot be downcast to Geom_BSplineCurve or Geom_BezierCurve.
OCCT: Geom_BSplineCurve::NbPoles / Geom_BezierCurve::NbPoles.

Example:

if let curve = Curve3D.bspline(poles: pts, knots: knots, multiplicities: mults, degree: 3) {
    if let n = curve.poleCount { /* n == pts.count */ }
}

`poles`

All poles (control points) of a B-spline or Bézier curve.

public var poles: [SIMD3<Double>]? { get }

Returns: Array of pole positions in model space, or nil if the curve is not a B-spline/Bézier or retrieval fails.
OCCT: Geom_BSplineCurve::Pole / Geom_BezierCurve::Pole (iterated via NbPoles).

Example:

if let curve = Curve3D.bspline(poles: pts, knots: knots, multiplicities: mults, degree: 3),
   let poles = curve.poles {
    for p in poles { print(p) }
}

`degree`

Polynomial degree of the B-spline or Bézier curve.

public var degree: Int { get }

Returns: Degree of the curve, or -1 if the curve is not a B-spline or Bézier.
OCCT: Geom_BSplineCurve::Degree / Geom_BezierCurve::Degree.

Example:

if let curve = Curve3D.bspline(poles: pts, knots: knots, multiplicities: mults, degree: 3) {
    let d = curve.degree  // 3
}

BSpline Knot Splitting (v0.40.0)

`ContinuityOrder` (removed in v2.0.0)

Renamed to ParametricContinuity in #398; the compatibility typealias itself was removed at v2.0.0 (#784). Use ParametricContinuity directly.

The old enum stopped at .c2, which made every order it could express a no-op for the query it exists to answer: GeomConvert_BSplineCurveKnotSplitting splits where degree - multiplicity < ContinuityRange, and an ordinary cubic interpolation has interior knots of multiplicity 1, so it is already C2 there. Measured on a degree-3 interpolated BSpline, ranges 0, 1 and 2 all return just the two end knots; range 3 returns five parameters. ParametricContinuity.c3 is reachable and fixes that. OCCT itself accepts any range >= 0 and saturates at the curve’s own degree, so on a degree-4-or-higher BSpline .c3 is the strictest question this vocabulary can ask; toBezierSegments() is the dedicated API for the every-knot split at the far end of that ladder. The same cap and the same fix apply to the surface, law and 2D-curve siblings (#480).

Pass to continuityBreaks(minContinuity:) to specify the minimum required continuity across knots.

`continuityBreaks(minContinuity:)`

Knot parameters at which to split the B-spline so that every resulting arc is at least minContinuity.

public func continuityBreaks(minContinuity: ParametricContinuity = .c1) -> [Double]?

Only works on Geom_BSplineCurve. The result is a set of split parameters, not a set of defects: the curve’s own first and last knots are always included, so a curve that never drops below minContinuity returns exactly those two rather than an empty array. Any further entries are interior knots where the curve really is less continuous than asked. Useful for splitting a composite B-spline into smooth segments.

Parameters: minContinuity — minimum continuity to require of each resulting arc (default .c1).
Returns: Split parameters in ascending order, bounded by the curve’s end knots, or nil if the curve is not a B-spline.
OCCT: GeomConvert_BSplineCurveKnotSplitting::NbSplits / SplitValue, resolved via Geom_BSplineCurve::Knot.

Example:

if let curve = Curve3D.bspline(poles: pts, knots: knots, multiplicities: mults, degree: 3),
   let breaks = curve.continuityBreaks(minContinuity: .c1) {
    let segments = curve.toBezierSegments() // split at each break
}

Geom_Circle Properties (v0.108.0)

`circleProperties`

Returns the circle-specific property accessor for this curve.

public var circleProperties: CircleProperties { get }

Meaningful only when the curve wraps a Geom_Circle. Accessing members on a non-circle returns zero.

Returns: A CircleProperties value backed by the same internal handle.
OCCT: Geom_Circle — accessed via Handle(Geom_Circle)::DownCast.

Example:

if let curve = Curve3D.circle(center: .zero, normal: SIMD3(0, 0, 1), radius: 5) {
    let cp = curve.circleProperties
}

`CircleProperties.radius`

The radius of the circle.

public var radius: Double { get }

Returns: Radius in model units, or 0 if the curve is not a Geom_Circle.
OCCT: Geom_Circle::Radius.

Example:

if let curve = Curve3D.circle(center: .zero, normal: SIMD3(0, 0, 1), radius: 5) {
    let r = curve.circleProperties.radius  // 5.0
}

`CircleProperties.setRadius(_:)`

Mutates the circle’s radius in place.

@discardableResult
public func setRadius(_ r: Double) -> Bool

Parameters: r: new radius, must be > 0.
Returns: true if the radius was written, false if the curve is not a circle or r is not a valid radius. On false the curve is left exactly as it was.
OCCT: Geom_Circle::SetRadius.

Example:

if let curve = Curve3D.circle(center: .zero, normal: SIMD3(0, 0, 1), radius: 5) {
    #expect(curve.circleProperties.setRadius(8) == true)

    // Rejected, and the radius set above survives.
    #expect(curve.circleProperties.setRadius(0) == false)
    #expect(curve.circleProperties.radius == 8)
}

`CircleProperties.eccentricity`

The eccentricity of the circle (always 0.0).

public var eccentricity: Double { get }

Returns: 0.0 for any circle; 0 if the curve is not a circle.
OCCT: Geom_Circle::Eccentricity.

Example:

if let curve = Curve3D.circle(center: .zero, normal: SIMD3(0, 0, 1), radius: 5) {
    let e = curve.circleProperties.eccentricity  // 0.0
}

`CircleProperties.center`

The centre point of the circle.

public var center: SIMD3<Double> { get }

Returns: Centre position in model space, or .zero if the curve is not a circle.
OCCT: Geom_Circle::Circ().Location() via gp_Circ::Location.

Example:

if let curve = Curve3D.circle(center: SIMD3(1, 2, 3), normal: SIMD3(0, 0, 1), radius: 5) {
    let c = curve.circleProperties.center  // SIMD3(1, 2, 3)
}

`CircleProperties.xAxis`

The X axis of the circle’s local frame: a position point and direction.

public var xAxis: (position: SIMD3<Double>, direction: SIMD3<Double>) { get }

The X axis lies in the circle’s plane, pointing toward the zero-angle parameter position.

Returns: Tuple (position, direction). Returns (.zero, .zero) if the curve is not a circle.
OCCT: Geom_Circle::XAxis → gp_Ax1::Location + gp_Ax1::Direction.

Example:

if let curve = Curve3D.circle(center: .zero, normal: SIMD3(0, 0, 1), radius: 5) {
    let ax = curve.circleProperties.xAxis
}

`CircleProperties.yAxis`

The Y axis of the circle’s local frame: a position point and direction.

public var yAxis: (position: SIMD3<Double>, direction: SIMD3<Double>) { get }

The Y axis lies in the circle’s plane, 90° counterclockwise from the X axis.

Returns: Tuple (position, direction). Returns (.zero, .zero) if the curve is not a circle.
OCCT: Geom_Circle::YAxis → gp_Ax1::Location + gp_Ax1::Direction.

Example:

if let curve = Curve3D.circle(center: .zero, normal: SIMD3(0, 0, 1), radius: 5) {
    let ay = curve.circleProperties.yAxis
}

Geom_Ellipse Properties (v0.108.0)

`ellipseProperties`

Returns the ellipse-specific property accessor for this curve.

public var ellipseProperties: EllipseProperties { get }

Meaningful only when the curve wraps a Geom_Ellipse. Accessing members on a non-ellipse returns zero.

Returns: An EllipseProperties value backed by the same internal handle.
OCCT: Geom_Ellipse — accessed via Handle(Geom_Ellipse)::DownCast.

Example:

if let curve = Curve3D.ellipse(center: .zero, normal: SIMD3(0, 0, 1),
                                majorRadius: 10, minorRadius: 5) {
    let ep = curve.ellipseProperties
}

`EllipseProperties.majorRadius`

The major radius (semi-major axis length).

public var majorRadius: Double { get }

Returns: Major radius in model units, or 0 if the curve is not a Geom_Ellipse.
OCCT: Geom_Ellipse::MajorRadius.

Example:

if let curve = Curve3D.ellipse(center: .zero, normal: SIMD3(0, 0, 1),
                                majorRadius: 10, minorRadius: 5) {
    let R = curve.ellipseProperties.majorRadius  // 10.0
}

`EllipseProperties.minorRadius`

The minor radius (semi-minor axis length).

public var minorRadius: Double { get }

Returns: Minor radius in model units, or 0 if the curve is not a Geom_Ellipse.
OCCT: Geom_Ellipse::MinorRadius.

Example:

if let curve = Curve3D.ellipse(center: .zero, normal: SIMD3(0, 0, 1),
                                majorRadius: 10, minorRadius: 5) {
    let r = curve.ellipseProperties.minorRadius  // 5.0
}

`EllipseProperties.setMajorRadius(_:)`

Mutates the ellipse’s major radius in place.

@discardableResult
public func setMajorRadius(_ r: Double) -> Bool

Parameters: r: new major radius. Judged against the minor radius already on the curve, so it must be > 0 and no smaller than the current minorRadius.
Returns: true if the radius was written, false if the curve is not an ellipse or the resulting pair would not describe one. On false the curve is left exactly as it was.
OCCT: Geom_Ellipse::SetMajorRadius.

Example:

if let curve = Curve3D.ellipse(center: .zero, normal: SIMD3(0, 0, 1),
                                majorRadius: 10, minorRadius: 5) {
    #expect(curve.ellipseProperties.setMajorRadius(12) == true)

    // Below the current minor radius: no longer an ellipse.
    #expect(curve.ellipseProperties.setMajorRadius(3) == false)
    #expect(curve.ellipseProperties.majorRadius == 12)
}

`EllipseProperties.setMinorRadius(_:)`

Mutates the ellipse’s minor radius in place.

@discardableResult
public func setMinorRadius(_ r: Double) -> Bool

Parameters: r: new minor radius. Judged against the major radius already on the curve, so it must be > 0 and no larger than the current majorRadius.
Returns: true if the radius was written, false if the curve is not an ellipse or the resulting pair would not describe one. On false the curve is left exactly as it was.
OCCT: Geom_Ellipse::SetMinorRadius.

Example:

if let curve = Curve3D.ellipse(center: .zero, normal: SIMD3(0, 0, 1),
                                majorRadius: 10, minorRadius: 5) {
    #expect(curve.ellipseProperties.setMinorRadius(3) == true)

    // Zero would leave a live ellipse evaluating onto its own major axis.
    #expect(curve.ellipseProperties.setMinorRadius(0) == false)
    #expect(curve.ellipseProperties.minorRadius == 3)
}

`EllipseProperties.eccentricity`

The eccentricity of the ellipse (0 < e < 1).

public var eccentricity: Double { get }

Returns: Eccentricity e = sqrt(1 − (b/a)²), or 0 if the curve is not an ellipse.
OCCT: Geom_Ellipse::Eccentricity.

Example:

if let curve = Curve3D.ellipse(center: .zero, normal: SIMD3(0, 0, 1),
                                majorRadius: 10, minorRadius: 5) {
    let e = curve.ellipseProperties.eccentricity  // ≈ 0.866
}

`EllipseProperties.focal`

The focal distance (distance between the two foci, i.e. 2c).

public var focal: Double { get }

Returns: 2 * sqrt(a² − b²), or 0 if the curve is not an ellipse.
OCCT: Geom_Ellipse::Focal.

Example:

if let curve = Curve3D.ellipse(center: .zero, normal: SIMD3(0, 0, 1),
                                majorRadius: 10, minorRadius: 5) {
    let f = curve.ellipseProperties.focal  // ≈ 17.32
}

`EllipseProperties.focus1`

The first focus point.

public var focus1: SIMD3<Double> { get }

Returns: First focus position in model space, or .zero if the curve is not an ellipse.
OCCT: Geom_Ellipse::Focus1.

Example:

if let curve = Curve3D.ellipse(center: .zero, normal: SIMD3(0, 0, 1),
                                majorRadius: 10, minorRadius: 5) {
    let f1 = curve.ellipseProperties.focus1
}

`EllipseProperties.focus2`

The second focus point.

public var focus2: SIMD3<Double> { get }

Returns: Second focus position in model space, or .zero if the curve is not an ellipse.
OCCT: Geom_Ellipse::Focus2.

Example:

if let curve = Curve3D.ellipse(center: .zero, normal: SIMD3(0, 0, 1),
                                majorRadius: 10, minorRadius: 5) {
    let f2 = curve.ellipseProperties.focus2
}

`EllipseProperties.parameter`

The semi-latus rectum (b² / a).

public var parameter: Double { get }

Returns: Semi-latus rectum in model units, or 0 if the curve is not an ellipse.
OCCT: Geom_Ellipse::Parameter.

Example:

if let curve = Curve3D.ellipse(center: .zero, normal: SIMD3(0, 0, 1),
                                majorRadius: 10, minorRadius: 5) {
    let p = curve.ellipseProperties.parameter  // 2.5 (25/10)
}

`EllipseProperties.directrix1`

The first directrix (position + direction).

public var directrix1: (position: SIMD3<Double>, direction: SIMD3<Double>) { get }

The directrix is perpendicular to the major axis. Its distance from the centre is a / e.

Returns: Tuple (position, direction). Returns (.zero, .zero) if the curve is not an ellipse.
OCCT: Geom_Ellipse::Directrix1 → gp_Ax1::Location + gp_Ax1::Direction.

Example:

if let curve = Curve3D.ellipse(center: .zero, normal: SIMD3(0, 0, 1),
                                majorRadius: 10, minorRadius: 5) {
    let d1 = curve.ellipseProperties.directrix1
}

Geom_Hyperbola Properties (v0.108.0)

`hyperbolaProperties`

Returns the hyperbola-specific property accessor for this curve.

public var hyperbolaProperties: HyperbolaProperties { get }

Meaningful only when the curve wraps a Geom_Hyperbola. Accessing members on a non-hyperbola returns zero.

Returns: A HyperbolaProperties value backed by the same internal handle.
OCCT: Geom_Hyperbola — accessed via Handle(Geom_Hyperbola)::DownCast.

Example:

if let curve = Curve3D.hyperbola(center: .zero, normal: SIMD3(0, 0, 1),
                                  majorRadius: 5, minorRadius: 3) {
    let hp = curve.hyperbolaProperties
}

`HyperbolaProperties.majorRadius`

The major radius (real semi-axis).

public var majorRadius: Double { get }

Returns: Real semi-axis length in model units, or 0 if the curve is not a Geom_Hyperbola.
OCCT: Geom_Hyperbola::MajorRadius.

Example:

if let curve = Curve3D.hyperbola(center: .zero, normal: SIMD3(0, 0, 1),
                                  majorRadius: 5, minorRadius: 3) {
    let a = curve.hyperbolaProperties.majorRadius  // 5.0
}

`HyperbolaProperties.minorRadius`

The minor radius (imaginary semi-axis).

public var minorRadius: Double { get }

Returns: Imaginary semi-axis length in model units, or 0 if the curve is not a Geom_Hyperbola.
OCCT: Geom_Hyperbola::MinorRadius.

Example:

if let curve = Curve3D.hyperbola(center: .zero, normal: SIMD3(0, 0, 1),
                                  majorRadius: 5, minorRadius: 3) {
    let b = curve.hyperbolaProperties.minorRadius  // 3.0
}

`HyperbolaProperties.setMajorRadius(_:)`

Mutates the hyperbola’s major radius in place.

@discardableResult
public func setMajorRadius(_ r: Double) -> Bool

Parameters: r: new major radius, must be > 0. Unlike an ellipse there is no ordering constraint against the minor radius.
Returns: true if the radius was written, false if the curve is not a hyperbola or r is not a valid radius. On false the curve is left exactly as it was.
OCCT: Geom_Hyperbola::SetMajorRadius.

Example:

if let curve = Curve3D.hyperbola(center: .zero, normal: SIMD3(0, 0, 1),
                                  majorRadius: 5, minorRadius: 3) {
    #expect(curve.hyperbolaProperties.setMajorRadius(7) == true)
    #expect(curve.hyperbolaProperties.setMajorRadius(0) == false)
    #expect(curve.hyperbolaProperties.majorRadius == 7)
}

`HyperbolaProperties.setMinorRadius(_:)`

Mutates the hyperbola’s minor radius in place.

@discardableResult
public func setMinorRadius(_ r: Double) -> Bool

Parameters: r: new minor radius, must be > 0. It may exceed the major radius.
Returns: true if the radius was written, false if the curve is not a hyperbola or r is not a valid radius. On false the curve is left exactly as it was.
OCCT: Geom_Hyperbola::SetMinorRadius.

Example:

if let curve = Curve3D.hyperbola(center: .zero, normal: SIMD3(0, 0, 1),
                                  majorRadius: 5, minorRadius: 3) {
    #expect(curve.hyperbolaProperties.setMinorRadius(4) == true)

    // A minor radius above the major is an ordinary hyperbola, so this is accepted.
    #expect(curve.hyperbolaProperties.setMinorRadius(8) == true)
    #expect(curve.hyperbolaProperties.setMinorRadius(0) == false)
}

`HyperbolaProperties.eccentricity`

The eccentricity of the hyperbola (e > 1).

public var eccentricity: Double { get }

Returns: e = sqrt(1 + (b/a)²) > 1, or 0 if the curve is not a hyperbola.
OCCT: Geom_Hyperbola::Eccentricity.

Example:

if let curve = Curve3D.hyperbola(center: .zero, normal: SIMD3(0, 0, 1),
                                  majorRadius: 5, minorRadius: 3) {
    let e = curve.hyperbolaProperties.eccentricity  // ≈ 1.166
}

`HyperbolaProperties.focal`

The focal distance (distance between the two foci, i.e. 2c).

public var focal: Double { get }

Returns: 2 * sqrt(a² + b²), or 0 if the curve is not a hyperbola.
OCCT: Geom_Hyperbola::Focal.

Example:

if let curve = Curve3D.hyperbola(center: .zero, normal: SIMD3(0, 0, 1),
                                  majorRadius: 5, minorRadius: 3) {
    let f = curve.hyperbolaProperties.focal  // ≈ 11.66
}

`HyperbolaProperties.focus1`

The first focus point.

public var focus1: SIMD3<Double> { get }

Returns: First focus in model space, or .zero if the curve is not a hyperbola.
OCCT: Geom_Hyperbola::Focus1.

Example:

if let curve = Curve3D.hyperbola(center: .zero, normal: SIMD3(0, 0, 1),
                                  majorRadius: 5, minorRadius: 3) {
    let f1 = curve.hyperbolaProperties.focus1
}

`HyperbolaProperties.asymptote1`

The first asymptote (position + direction).

public var asymptote1: (position: SIMD3<Double>, direction: SIMD3<Double>) { get }

For a standard hyperbola with semi-axes a, b, the asymptote direction is (a, b, 0) (normalised). The two asymptotes are symmetric about the transverse axis.

Returns: Tuple (position, direction). Returns (.zero, .zero) if the curve is not a hyperbola.
OCCT: Geom_Hyperbola::Asymptote1 → gp_Ax1::Location + gp_Ax1::Direction.

Example:

if let curve = Curve3D.hyperbola(center: .zero, normal: SIMD3(0, 0, 1),
                                  majorRadius: 5, minorRadius: 3) {
    let a1 = curve.hyperbolaProperties.asymptote1
}

Geom_Parabola Properties (v0.108.0)

`parabolaProperties`

Returns the parabola-specific property accessor for this curve.

public var parabolaProperties: ParabolaProperties { get }

Meaningful only when the curve wraps a Geom_Parabola. Accessing members on a non-parabola returns zero.

Returns: A ParabolaProperties value backed by the same internal handle.
OCCT: Geom_Parabola — accessed via Handle(Geom_Parabola)::DownCast.

Example:

if let curve = Curve3D.parabola(vertex: .zero, normal: SIMD3(0, 0, 1), focal: 3) {
    let pp = curve.parabolaProperties
}

`ParabolaProperties.focal`

The focal distance of the parabola.

public var focal: Double { get }

Distance from the vertex to the focus. The directrix is the same distance on the opposite side of the vertex.

Returns: Focal length in model units, or 0 if the curve is not a Geom_Parabola.
OCCT: Geom_Parabola::Focal.

Example:

if let curve = Curve3D.parabola(vertex: .zero, normal: SIMD3(0, 0, 1), focal: 3) {
    let f = curve.parabolaProperties.focal  // 3.0
}

`ParabolaProperties.setFocal(_:)`

Mutates the parabola’s focal distance in place.

@discardableResult
public func setFocal(_ f: Double) -> Bool

Parameters: f: new focal distance, must be > 0. At zero the parabola degenerates to a straight line along its own axis of symmetry, which is gp_Parab’s documented behaviour rather than an error it reports.
Returns: true if the value was written, false if the curve is not a parabola or f is not a valid focal distance. On false the curve is left exactly as it was.
OCCT: Geom_Parabola::SetFocal.

Example:

if let curve = Curve3D.parabola(center: .zero, normal: SIMD3(0, 0, 1), focal: 3) {
    #expect(curve.parabolaProperties.setFocal(5) == true)
    #expect(curve.parabolaProperties.setFocal(0) == false)
    #expect(curve.parabolaProperties.focal == 5)
}

`ParabolaProperties.focus`

The focus point of the parabola.

public var focus: SIMD3<Double> { get }

Returns: Focus position in model space, or .zero if the curve is not a parabola.
OCCT: Geom_Parabola::Focus.

Example:

if let curve = Curve3D.parabola(vertex: .zero, normal: SIMD3(0, 0, 1), focal: 3) {
    let fpt = curve.parabolaProperties.focus
}

`ParabolaProperties.eccentricity`

The eccentricity of the parabola (always 1.0).

public var eccentricity: Double { get }

Returns: 1.0 for any parabola; 0 if the curve is not a parabola.
OCCT: Geom_Parabola::Eccentricity.

Example:

if let curve = Curve3D.parabola(vertex: .zero, normal: SIMD3(0, 0, 1), focal: 3) {
    let e = curve.parabolaProperties.eccentricity  // 1.0
}

`ParabolaProperties.parameter`

The parameter of the parabola (2 * focal).

public var parameter: Double { get }

Half the length of the latus rectum; the perpendicular chord through the focus.

Returns: 2 * focal in model units, or 0 if the curve is not a parabola.
OCCT: Geom_Parabola::Parameter.

Example:

if let curve = Curve3D.parabola(vertex: .zero, normal: SIMD3(0, 0, 1), focal: 3) {
    let p = curve.parabolaProperties.parameter  // 6.0
}

`ParabolaProperties.directrix`

The directrix of the parabola (position + direction).

public var directrix: (position: SIMD3<Double>, direction: SIMD3<Double>) { get }

The directrix is a line perpendicular to the parabola’s axis at distance focal on the opposite side of the vertex from the focus.

Returns: Tuple (position, direction). Returns (.zero, .zero) if the curve is not a parabola.
OCCT: Geom_Parabola::Directrix → gp_Ax1::Location + gp_Ax1::Direction.

Example:

if let curve = Curve3D.parabola(vertex: .zero, normal: SIMD3(0, 0, 1), focal: 3) {
    let d = curve.parabolaProperties.directrix
}

Geom_Line Properties (v0.108.0)

`lineProperties`

Returns the line-specific property accessor for this curve.

public var lineProperties: LineProperties { get }

Meaningful only when the curve wraps a Geom_Line. Accessing members on a non-line returns zero.

Returns: A LineProperties value backed by the same internal handle.
OCCT: Geom_Line — accessed via Handle(Geom_Line)::DownCast.

Example:

if let curve = Curve3D.line(origin: .zero, direction: SIMD3(1, 0, 0)) {
    let lp = curve.lineProperties
}

`LineProperties.direction`

The unit direction vector of the line.

public var direction: SIMD3<Double> { get }

Returns: Unit direction, or .zero if the curve is not a Geom_Line.
OCCT: Geom_Line::Lin().Direction().

Example:

if let curve = Curve3D.line(origin: .zero, direction: SIMD3(1, 0, 0)) {
    let d = curve.lineProperties.direction  // SIMD3(1, 0, 0)
}

`LineProperties.location`

The origin (location) point of the line.

public var location: SIMD3<Double> { get }

Returns: Origin position in model space, or .zero if the curve is not a line.
OCCT: Geom_Line::Lin().Location().

Example:

if let curve = Curve3D.line(origin: SIMD3(1, 2, 3), direction: SIMD3(0, 0, 1)) {
    let loc = curve.lineProperties.location  // SIMD3(1, 2, 3)
}

`LineProperties.setDirection(_:)`

Mutates the line’s direction in place.

@discardableResult
public func setDirection(_ d: SIMD3<Double>) -> Bool

Parameters: d — new direction (will be normalised by OCCT via gp_Dir; must be non-zero).
Returns: true on success, false if the curve is not a line or d is degenerate.
OCCT: Geom_Line::SetDirection.

Example:

if let curve = Curve3D.line(origin: .zero, direction: SIMD3(1, 0, 0)) {
    curve.lineProperties.setDirection(SIMD3(0, 1, 0))
}

`LineProperties.setLocation(_:)`

Mutates the line’s origin point in place.

@discardableResult
public func setLocation(_ p: SIMD3<Double>) -> Bool

Parameters: p — new origin point.
Returns: true on success, false if the curve is not a line.
OCCT: Geom_Line::SetLocation.

Example:

if let curve = Curve3D.line(origin: .zero, direction: SIMD3(1, 0, 0)) {
    curve.lineProperties.setLocation(SIMD3(5, 0, 0))
}

`LineProperties.position`

The line’s position axis: origin location and unit direction.

public var position: (location: SIMD3<Double>, direction: SIMD3<Double>) { get }

Combines location and direction into a single call via the underlying gp_Ax1.

Returns: Tuple (location, direction). Returns (.zero, .zero) if the curve is not a line.
OCCT: Geom_Line::Position → gp_Ax1::Location + gp_Ax1::Direction.

Example:

if let curve = Curve3D.line(origin: SIMD3(1, 0, 0), direction: SIMD3(0, 1, 0)) {
    let pos = curve.lineProperties.position
}

`LineProperties.lin`

The gp_Lin representation: origin location and unit direction.

public var lin: (location: SIMD3<Double>, direction: SIMD3<Double>) { get }

Equivalent to position but reads the data via Geom_Line::Lin() rather than Geom_Line::Position(). Both return the same values in practice.

Returns: Tuple (location, direction). Returns (.zero, .zero) if the curve is not a line.
OCCT: Geom_Line::Lin() → gp_Lin::Location + gp_Lin::Direction.

Example:

if let curve = Curve3D.line(origin: .zero, direction: SIMD3(0, 0, 1)) {
    let l = curve.lineProperties.lin
}

Bezier Curve deep method completion (v0.125.0)

`bezierStartPoint`

The start point (first pole) of the Bézier curve.

public var bezierStartPoint: SIMD3<Double> { get }

Returns .zero if the curve is not a Geom_BezierCurve.

OCCT: Geom_BezierCurve::StartPoint.

Example:

if let curve = Curve3D.bezier(poles: [SIMD3(0,0,0), SIMD3(1,1,0), SIMD3(2,0,0)]) {
    let start = curve.bezierStartPoint  // SIMD3(0,0,0)
}

`bezierEndPoint`

The end point (last pole) of the Bézier curve.

public var bezierEndPoint: SIMD3<Double> { get }

Returns .zero if the curve is not a Geom_BezierCurve.

OCCT: Geom_BezierCurve::EndPoint.

Example:

if let curve = Curve3D.bezier(poles: [SIMD3(0,0,0), SIMD3(1,1,0), SIMD3(2,0,0)]) {
    let end = curve.bezierEndPoint  // SIMD3(2,0,0)
}

`bezierPoles`

All poles of the Bézier curve as an array.

public var bezierPoles: [SIMD3<Double>] { get }

Returns an empty array if the curve is not a Geom_BezierCurve or has no poles.

OCCT: Geom_BezierCurve::NbPoles + Geom_BezierCurve::Pole (iterated).

Example:

if let curve = Curve3D.bezier(poles: [SIMD3(0,0,0), SIMD3(1,1,0), SIMD3(2,0,0)]) {
    let pts = curve.bezierPoles  // count == 3
}

`bezierWeights`

All weights of the rational Bézier curve.

public var bezierWeights: [Double]? { get }

Returns: Array of weights (one per pole), or nil if the curve is non-rational or not a Bézier.
OCCT: Geom_BezierCurve::Weight (iterated) — returns nil when the curve is non-rational.

Example:

if let curve = Curve3D.bezier(poles: [SIMD3(0,0,0), SIMD3(1,1,0), SIMD3(2,0,0)],
                               weights: [1, 0.5, 1]) {
    if let w = curve.bezierWeights { print(w) }
}

`bezierIsClosed`

Whether the Bézier curve is geometrically closed.

public var bezierIsClosed: Bool { get }

Returns: true if the first and last pole coincide within tolerance; always false for non-Bézier curves.
OCCT: Geom_BezierCurve::IsClosed.

Example:

if let curve = Curve3D.bezier(poles: [SIMD3(0,0,0), SIMD3(1,1,0), SIMD3(0,0,0)]) {
    let closed = curve.bezierIsClosed  // true
}

`bezierIsPeriodic`

Whether the Bézier curve is periodic.

public var bezierIsPeriodic: Bool { get }

Bézier curves are never periodic in OCCT; this always returns false for Geom_BezierCurve.

Returns: false for any Bézier curve; false for non-Bézier curves.
OCCT: Geom_BezierCurve::IsPeriodic.

Example:

if let curve = Curve3D.bezier(poles: [SIMD3(0,0,0), SIMD3(1,1,0), SIMD3(2,0,0)]) {
    let p = curve.bezierIsPeriodic  // false
}

`bezierContinuity`

The global continuity class of the Bézier curve, as a raw GeomAbs_Shape ordinal (0 = C0, 1 = G1, 2 = C1, 3 = G2, 4 = C2, 5 = C3, 6 = CN).

public var bezierContinuity: Int { get }

A Bézier curve of degree ≥ 1 is always C∞ (returns 6 = CN). Returns 0 for non-Bézier curves.

OCCT: Geom_BezierCurve::Continuity → GeomAbs_Shape mapped to Int.

Example:

if let curve = Curve3D.bezier(poles: [SIMD3(0,0,0), SIMD3(1,1,0), SIMD3(2,0,0)]) {
    let cont = curve.bezierContinuity  // 6 (CN)
}

`bezierIsCN(_:)`

Whether the Bézier curve is at least Cn continuous.

public func bezierIsCN(_ n: Int) -> Bool

Parameters: n — required continuity order.
Returns: true if the curve is at least Cn; false for non-Bézier curves.
OCCT: Geom_BezierCurve::IsCN.

Example:

if let curve = Curve3D.bezier(poles: [SIMD3(0,0,0), SIMD3(1,1,0), SIMD3(2,0,0)]) {
    let ok = curve.bezierIsCN(2)  // true
}

Bezier 3D completions (v0.126.0)

`bezierInsertPoleBefore(_:point:)`

Insert a pole before a given index in the Bézier curve (1-based).

@discardableResult
public func bezierInsertPoleBefore(_ index: Int, point: SIMD3<Double>) -> Bool

Modifies the underlying Geom_BezierCurve in place, increasing the pole count by one and raising the degree by one.

Parameters:
- index — 1-based insertion position (the new pole is placed before this index).
- point — new control point position.
Returns: true on success, false if the curve is not a Bézier or the index is out of range.
OCCT: Geom_BezierCurve::InsertPoleAfter (called with index − 1 to implement before semantics).

Example:

if let curve = Curve3D.bezier(poles: [SIMD3(0,0,0), SIMD3(2,0,0)]) {
    curve.bezierInsertPoleBefore(2, point: SIMD3(1, 1, 0))
    // curve now has 3 poles
}

`bezierReverse()`

Reverse the parameterization of the Bézier curve in place.

@discardableResult
public func bezierReverse() -> Bool

Poles are reordered so the curve traces the same path in the opposite parameter direction.

Returns: true on success, false if the curve is not a Bézier.
OCCT: Geom_BezierCurve::Reverse.

Example:

if let curve = Curve3D.bezier(poles: [SIMD3(0,0,0), SIMD3(1,1,0), SIMD3(2,0,0)]) {
    curve.bezierReverse()
    let start = curve.bezierStartPoint  // now SIMD3(2,0,0)
}

`bezierSetPoleWithWeight(index:point:weight:)`

Set a pole and its weight simultaneously on a rational Bézier curve.

@discardableResult
public func bezierSetPoleWithWeight(index: Int, point: SIMD3<Double>, weight: Double) -> Bool

Parameters:
- index — 1-based pole index.
- point — new control point position.
- weight — new weight for the pole (must be > 0).
Returns: true on success, false if the curve is not a Bézier, the index is out of range, or the weight is non-positive.
OCCT: Geom_BezierCurve::SetPole + Geom_BezierCurve::SetWeight.

Example:

if let curve = Curve3D.bezier(poles: [SIMD3(0,0,0), SIMD3(1,1,0), SIMD3(2,0,0)],
                               weights: [1, 1, 1]) {
    curve.bezierSetPoleWithWeight(index: 2, point: SIMD3(1, 2, 0), weight: 0.5)
}

BSpline completions (v0.127.0)

`bsplinePeriodicNormalization(_:)`

Normalize a parameter value for a periodic B-spline curve.

public func bsplinePeriodicNormalization(_ u: Double) -> Double?

Maps an arbitrary parameter value into the curve’s fundamental period [first, first + period).

Parameters: u — raw parameter value.
Returns: Normalized parameter in the fundamental period, or nil if the curve is not a periodic B-spline.
OCCT: Geom_BSplineCurve::PeriodicNormalization.

Example:

if let curve = Curve3D.interpolatePeriodic(points: pts),
   let norm = curve.bsplinePeriodicNormalization(7.5) {
    let pt = curve.point(at: norm)
}

`bsplineIsG1(tFirst:tLast:angularTolerance:)`

Check G1 (tangent) continuity of a B-spline on a parameter range.

public func bsplineIsG1(tFirst: Double, tLast: Double, angularTolerance: Double = 0.01) -> Bool

Uses OCCT’s Geom_BSplineCurve::IsG1 to verify that the curve’s tangent direction changes by at most angularTolerance radians everywhere in [tFirst, tLast].

Parameters:
- tFirst — start of parameter range.
- tLast — end of parameter range.
- angularTolerance — angular tolerance in radians (default 0.01).
Returns: true if G1 continuous on the range; false otherwise or if the curve is not a B-spline.
OCCT: Geom_BSplineCurve::IsG1.

Example:

if let curve = Curve3D.bspline(poles: pts, knots: knots, multiplicities: mults, degree: 3) {
    let d = curve.domain
    let smooth = curve.bsplineIsG1(tFirst: d.lowerBound, tLast: d.upperBound)
}

Curve3D — Analytic Types

Topics

BSpline Queries

poleCount

poles

degree

BSpline Knot Splitting (v0.40.0)

ContinuityOrder (removed in v2.0.0)

continuityBreaks(minContinuity:)

Geom_Circle Properties (v0.108.0)

circleProperties

CircleProperties.radius

CircleProperties.setRadius(_:)

CircleProperties.eccentricity

CircleProperties.center

CircleProperties.xAxis

CircleProperties.yAxis

Geom_Ellipse Properties (v0.108.0)

ellipseProperties

EllipseProperties.majorRadius

EllipseProperties.minorRadius

EllipseProperties.setMajorRadius(_:)

EllipseProperties.setMinorRadius(_:)

EllipseProperties.eccentricity

EllipseProperties.focal

EllipseProperties.focus1

EllipseProperties.focus2

EllipseProperties.parameter

EllipseProperties.directrix1

Geom_Hyperbola Properties (v0.108.0)

hyperbolaProperties

HyperbolaProperties.majorRadius

HyperbolaProperties.minorRadius

HyperbolaProperties.setMajorRadius(_:)

HyperbolaProperties.setMinorRadius(_:)

HyperbolaProperties.eccentricity

HyperbolaProperties.focal

HyperbolaProperties.focus1

HyperbolaProperties.asymptote1

Geom_Parabola Properties (v0.108.0)

parabolaProperties

ParabolaProperties.focal

ParabolaProperties.setFocal(_:)

ParabolaProperties.focus

ParabolaProperties.eccentricity

ParabolaProperties.parameter

ParabolaProperties.directrix

Geom_Line Properties (v0.108.0)

lineProperties

LineProperties.direction

LineProperties.location

LineProperties.setDirection(_:)

LineProperties.setLocation(_:)

LineProperties.position

LineProperties.lin

Bezier Curve deep method completion (v0.125.0)

bezierStartPoint

bezierEndPoint

bezierPoles

bezierWeights

bezierIsClosed

bezierIsPeriodic

bezierContinuity

bezierIsCN(_:)

Bezier 3D completions (v0.126.0)

bezierInsertPoleBefore(_:point:)

bezierReverse()

bezierSetPoleWithWeight(index:point:weight:)

BSpline completions (v0.127.0)

bsplinePeriodicNormalization(_:)

bsplineIsG1(tFirst:tLast:angularTolerance:)

`poleCount`

`poles`

`degree`

`ContinuityOrder` (removed in v2.0.0)

`continuityBreaks(minContinuity:)`

`circleProperties`

`CircleProperties.radius`

`CircleProperties.setRadius(_:)`

`CircleProperties.eccentricity`

`CircleProperties.center`

`CircleProperties.xAxis`

`CircleProperties.yAxis`

`ellipseProperties`

`EllipseProperties.majorRadius`

`EllipseProperties.minorRadius`

`EllipseProperties.setMajorRadius(_:)`

`EllipseProperties.setMinorRadius(_:)`

`EllipseProperties.eccentricity`

`EllipseProperties.focal`

`EllipseProperties.focus1`

`EllipseProperties.focus2`

`EllipseProperties.parameter`

`EllipseProperties.directrix1`

`hyperbolaProperties`

`HyperbolaProperties.majorRadius`

`HyperbolaProperties.minorRadius`

`HyperbolaProperties.setMajorRadius(_:)`

`HyperbolaProperties.setMinorRadius(_:)`

`HyperbolaProperties.eccentricity`

`HyperbolaProperties.focal`

`HyperbolaProperties.focus1`

`HyperbolaProperties.asymptote1`

`parabolaProperties`

`ParabolaProperties.focal`

`ParabolaProperties.setFocal(_:)`

`ParabolaProperties.focus`

`ParabolaProperties.eccentricity`

`ParabolaProperties.parameter`

`ParabolaProperties.directrix`

`lineProperties`

`LineProperties.direction`

`LineProperties.location`

`LineProperties.setDirection(_:)`

`LineProperties.setLocation(_:)`

`LineProperties.position`

`LineProperties.lin`

`bezierStartPoint`

`bezierEndPoint`

`bezierPoles`

`bezierWeights`

`bezierIsClosed`

`bezierIsPeriodic`

`bezierContinuity`

`bezierIsCN(_:)`

`bezierInsertPoleBefore(_:point:)`

`bezierReverse()`

`bezierSetPoleWithWeight(index:point:weight:)`

`bsplinePeriodicNormalization(_:)`

`bsplineIsG1(tFirst:tLast:angularTolerance:)`