Link Search Menu Expand Document
OCCTSwift

Helical Sweeps

Sweeping a profile along a helix is how you build worms, augers, screw conveyors, and screw threads. OCCTSwift gives you two routes, and picking the right one matters:

  • Shape.helicalSweep(profile:…): sweeps a profile along an exact analytic helix into a standalone helicoid (a helical ridge / auger flight). Great on its own; not something to boolean onto a shaft.
  • Shape.threadedRod(customProfile:…): composes a custom tooth profile with a core cylinder directly, with no boolean, into a smooth, valid, analytic threaded rod (worm / screw).

If you only need a standard fastener thread (ISO, Unified, ACME, trapezoidal, square, buttress…), reach for threadedShaft / threadedHole with a ThreadForm spec instead, this page is for custom helical profiles.

A standalone helicoid

helicalSweep runs the profile along the helix using an auxiliary-spine framing, so the section stays roughly radial. A triangular rib over a few turns gives an auger-style flight:

let R = 3.0, crest = 6.0, pitch = 4.0

// rib profile in the (radial, axial) plane: inner edge at radius R, peak at `crest`.
guard let rib = Wire.polygon3D([SIMD3(R, 0, 0),
                                SIMD3(crest, 0, pitch * 0.4),
                                SIMD3(R, 0, pitch * 0.8)], closed: true),
      let ridge = Shape.helicalSweep(profile: rib,
                                     axisOrigin: .zero, axisDirection: SIMD3(0, 0, 1),
                                     radius: R, pitch: pitch, turns: 3) else { return }
// ridge.isValidSolid == true, a valid helicoid on its own

helicalSweep, a standalone helical ridge

Framing caveat. The auxiliary-spine framing isn’t exactly radial: the result bulges ~10–15% beyond the nominal radius for moderate profiles, and for narrow / fine-pitch profiles (e.g. ISO V forms) it balloons badly. Use helicalSweep for coarse worm/auger ribs, not precise fastener threads, and build threads with threadedRod / threadedShaft, which don’t use this path.

A worm / screw thread from a custom profile

To turn a custom tooth into an actual threaded rod, use Shape.threadedRod(customProfile:…). You give it a ThreadProfile, the tooth cross-section in normalized (axial, depth) coordinates: axial runs 0…1 over one pitch, and depth runs 0 (crest, at nominalDiameter / 2) to 1 (root, at nominalDiameter / 2 − cutDepth). Here a symmetric trapezoidal worm tooth:

guard let tooth = ThreadProfile(vertices: [
    .init(axial: 0.000, depth: 1), .init(axial: 0.125, depth: 1),   // root half-flat
    .init(axial: 0.375, depth: 0), .init(axial: 0.625, depth: 0),   // flanks up to the crest flat
    .init(axial: 0.875, depth: 1), .init(axial: 1.000, depth: 1),   // flank back down to the root
]),
      let worm = Shape.threadedRod(customProfile: tooth, nominalDiameter: 12,
                                   pitch: 5, cutDepth: 1.8, length: 22) else { return }
// worm.isValidSolid == true, smooth, analytic (a handful of B-spline faces → a small STEP),
// and built with NO boolean, so it's BRepCheck-valid where a boolean compose is not.

threadedRod, a smooth worm from a custom profile

🖱️ Drag to orbit · scroll to zoom · auto-rotating. (Models exported straight from the snippets above via Exporter.writeGLTF.)

The profile must be smooth-rod-buildable, a real crest flat and at most two flanks (trapezoidal / ACME / square / buttress / worm forms qualify). Check with tooth.supportsSmoothRodBuild. A pointed-crest or many-flank (rounded / knuckle) profile returns false, and threadedRod returns nil rather than silently producing an invalid result.

Don’t boolean a helicoid onto a cylinder

The intuitive way to make a thread, helicalSweep a rib, then union (or subtract) it with a coaxial cylinder whose surface is coincident with the helicoid’s inner edge, does not work:

// ❌ DON'T: OCCT's boolean engine can't resolve the coincident/tangent helicoid faces.
let core = Shape.cylinder(radius: 3, height: 13)!
let bad  = core.union(ridge)            // BRepCheck-INVALID (volume ~right, topology not)
// subtracting a continuous helicoid collapses to volume 0. fuzzyValue / healed() / sewn()
// don't recover either, this is inherent, not a tuning problem (OCCTSwift #225, #213, #181).

threadedRod exists precisely to avoid this: it lofts the thread region (ruled:false cam slices of the profile, swept along the exact helix) and sews it to the core, the boolean engine is never invoked, so the result is valid and analytic.

See also