How to flatten a genericSweep?

[gmlewis]

I'm sweeping a rectangle outline along a helix path, but genericSweep is rotating the outline as it progresses, and I need it to be flat (unrotated about its normal). I tried changing the GenericSweepConfig settings, but couldn't get auxiliarySpline or any of the other options to change this.

Here's the code:

const r = replicad

const wireSize = 1
const wireGap = 0.5
const innerRadius = 3
const vertTurns = 1

const main = () => {
  const shapes = []

  const path1 = r.makeHelix(2*(wireSize+wireGap), 2*vertTurns*(wireSize+wireGap), innerRadius)
  const outline = r.drawRectangle(1,1).translate(innerRadius,0).sketchOnPlane('XZ')
  const swp1 = r.genericSweep(
    outline.wire,
    r.assembleWire(path1.wires),
    { forceProfileSpineOthogonality: true },
    false,
  )
  shapes.push(swp1)
  
  const swp2 = r.genericSweep(
    outline.wire,
    r.assembleWire(path1.wires),
    { forceProfileSpineOthogonality: false },
    false,
  ).rotate(180, [0,0,0], [0,0,1])
  shapes.push(swp2)

  return shapes
}

and here is what it generates:

What I would like instead is something like this:

Any ideas how to fix this?

[raydeleu]

I am trying to get it right, but my first idea is that it has to do with the translate. My understanding is that you have to draw a cross section and reference this to a generic origin and plane, and then feed this to the sweep function. See the examples in https://github.com/raydeleu/ReplicadManual/wiki/5.-Create-solid-shapes. I only used the sweepSketch function, so I have to figure out how the genericSweep works.

[raydeleu]

I was not able to get it right, not even using the sweepSketch method. The wire created with makeHelix cannot be used with the sweepSketch method. Perhaps a workaround can solve your issue. In CascadeStudio Kurt Hutten created a workaround for a helix-loft, see my explanation in:

https://github.com/raydeleu/CascadeStudioManual?tab=readme-ov-file#95-loft

It should be possible to adapt the code to Replicad.

[raydeleu]

I created the following example:

Using the code below:

let thread=[]
for (let h = 1; h <= 360; h++)
{
    let plane = makePlane("XZ").pivot(h, "Z");
    let wire = drawRectangle(4,4).translate([10,10/360*h]).sketchOnPlane(plane)
    thread.push(wire)
}

let startPlane = makePlane("XZ").translate([10,0,0])
let startSection = drawRectangle(4,4).sketchOnPlane(startPlane)
let completeThread = startSection.loftWith(thread)

shapes.push(completeThread)

[sgenoud]

I think the option you are looking for is the "frenet" one. Is this what you want to do?

P.S. I am not sure why or how, but this is what I have found out with playing with the different options opencascade offers.

[raydeleu]

An interesting difference between these solutions is that with the frenet option the section is perfectly perpendicular to the wire. Even the first section is slightly angled from the "XZ" plane to follow the helix perfectly. My solution is like a spiral staircase, the solution offered by sgenoud is a perfect pipe.

@sgenoud: Do you have any idea why the wire created with makeHelix cannot be used with the sweepSketch method?

const path1 = makeHelix(2*(wireSize+wireGap), 2*vertTurns*(wireSize+wireGap), innerRadius)
const path2 = assembleWire(path1.wires) 
const swp3 = path1.sweepSketch((plane,origin)=>sketchRectangle(1,1,{plane,origin}))

In the code above using sweepSketch on path1 and on path2 fails.

[sgenoud]

An interesting difference between these solutions is that with the frenet option the section is perfectly perpendicular to the wire. Even the first section is slightly angled from the "XZ" plane to follow the helix perfectly. My solution is like a spiral staircase, the solution offered by sgenoud is a perfect pipe.

With the forceProfileSpineOthogonality: false you also get the staircase version, aren't you?

Make helix returns an edge - a 3D edge. You can only sweepSketch sketches - and makeHelix returns an edge. I should add a SketchHelixfunction that works that way

const { makeHelix, Sketch, assembleWire, drawRectangle } = replicad

const wireSize = 1
const wireGap = 0.5
const innerRadius = 3
const vertTurns = 1

const sketchHelix = (
  pitch,
  height,
  radius,
  center = [0, 0, 0],
  dir = [0, 0, 1],
  lefthand = false
) => {
  return new Sketch(
    assembleWire(
      makeHelix(pitch, height, radius, center, dir, lefthand).wires
    )
  )
}

const main = () => {

  return sketchHelix(
    2 * (wireSize + wireGap),
    2 * vertTurns * (wireSize + wireGap),
    innerRadius
  ).sweepSketch(
    () => drawRectangle(1, 1).sketchOnPlane("YZ", innerRadius),
    { frenet: true }
  )
}

The reason is that I created the makeHelix function before thinking of the whole sketch interface.

[raydeleu]

This image shows that indeed the staircase can be produced with the forceProfileSpineOthogonality: false.

const r = replicad

const wireSize = 1
const wireGap = 0.5
const innerRadius = 3
const vertTurns = 1

const main = () => {
  const shapes = []

  const path1 = r.makeHelix(2*(wireSize+wireGap), 2*vertTurns*(wireSize+wireGap), innerRadius)
  const outline = r.drawRectangle(1,1).translate(innerRadius,0).sketchOnPlane('XZ')
  const swp1 = r.genericSweep(
    outline.wire,
    r.assembleWire(path1.wires),
    { forceProfileSpineOthogonality: true, frenet:true },
    false,
  )
  shapes.push(swp1)
  
  const swp2 = r.genericSweep(
    outline.wire,
    r.assembleWire(path1.wires),
    { forceProfileSpineOthogonality: false, frenet: true },
    false,
  ).rotate(180, [0,0,0], [0,0,1])
  shapes.push(swp2)

  return [
  {shape:swp1, color:"orange"},
  {shape: swp2, color:"steelblue"}]
}

A helix sweep seems to be a complex shape. The term frenet refers to a French mathematician, see https://en.wikipedia.org/wiki/Frenet%E2%80%93Serret_formulas. If you look at the following animation it is clear that there is no rotation along the helix when the frame moves up, so the radius alway stays perpendicular to the z-axis.

[sgenoud]

With the latest version, sketchHelix has been added as a sketch function in replicad!

[gmlewis]

Wow, you are both amazing! I would like to mark every reply as "the answer" because every one has valuable gems in it.
But yes, @sgenoud - that is exactly what I was trying to do... thank you very much!

[gmlewis]

Quick question that I don't really want to open up a completely separate Issue or Discussion topic for...

Is there a way to run your workbench within a VSCode/Zed panel so that a save of the code on the left immediately updates the viewer on the right? Something along the lines of glsl-viewer?

I love the official workbench (although I would love a dark mode for the viewer side even more 😄 ), but keep wanting to hit "save" for fear of losing my design, and I would like to work out of a repo so I can put the design under git version control.

I saw this discussion but it was not obvious to me how to start the local visualizer. I also found this and tried it out, but again couldn't find the visualizer, sorry for the stupid quesitons.

EDIT: Ah, sorry, I think I found it! https://replicad.xyz/docs/tutorial-overview/using-the-workbench#working-with-local-files

[raydeleu]

You might also look at https://github.com/raydeleu/ReplicadManual/wiki/B.-Installing-Replicad-locally. I assume you can combine this with the solution you mentioned above to point the visualizer or the workbench to a local file. Please be aware that my manual is not the official one, only a best effort and work in progress to describe what I have found out working with Replicad.

[gmlewis]

@sgenoud - I'm noticing that the start and end faces of the pipe mechanism above don't have the same normal as the original wire outline, and it seems to get worse for smaller radii helices. I've attached a screenshot and highlighted in red what I'm talking about.
I'm not sure yet if this is going to cause a problem... but maybe if I could loft the connectors to the actual resulting end faces, then maybe it won't be a problem after all. Just interesting to note at this point.

(Oh, I forgot to mention that this view is from clicking on the 'Z' in the gizmo on the lower right, so this should be an orthogonal 'top' view.)

[gmlewis]

Ah! I think I'm just figuring out that clicking on the 'Z' maybe does NOT given an orthogonal top view!!!
So Maybe this is completely a non-issue and due to always seeing a perspective view!
Never mind. Sorry for the noise.
EDIT: See comment below about verifying this is indeed actually the case by pulling exported STLs into Blender.

[gmlewis]

Just for reference, a few years back I had created a viewer gizmo in three.js where if you click on any of the labeled faces, you get an orthogonal view, but if you click on a corner, you get a perspective view, very similar to Onshape:

https://gmlewis.github.io/irmf-editor/

[sgenoud]

Thanks, I will definitely have a look at this gizmo - the one I use is from here - but I should improve on it!

[gmlewis]

Update: I exported the model as STL and imported into Blender and verified that the faces are indeed not facing the same direction as the original rectangle outline. I'll go edit my earlier comments to reduce confusion, hopefully.

[gmlewis]

For reference, here is my design so far:

const r = replicad

const fuseAll = false

// tweakable parameters:
const wireWidth = 1
const wireGap = 0.5
const innerRadius = 3
const vertTurns = 1 // 15
const maxDiameter = 38
const connectorThickness = 1

// calculated constants:
const numPairs = Math.floor((maxDiameter - 2*innerRadius - 2*connectorThickness) / (2 * (wireWidth + wireGap)))
const deltaY = (numPairs > 1) ? (wireWidth + wireGap) / (numPairs - 1) : 0

const coilPair = (i) => {
  const zOffset = (i - 1) * deltaY // - wireWidth/2
  const radius = innerRadius + wireWidth/2 + i*(wireWidth + wireGap)

  const path1 = r.makeHelix(2*(wireWidth+wireGap), 2*vertTurns*(wireWidth+wireGap), radius)
  const outline = r.drawRectangle(1,1).translate(radius,0).sketchOnPlane('XZ')
  const makeCoil = () => r.genericSweep(
    outline.wire,
    r.assembleWire(path1.wires),
    { forceProfileSpineOthogonality: true, frenet:true },
    false,
  ).translateZ(zOffset)
  const swp1 = makeCoil()
  const swp2 = makeCoil().rotate(180, [0,0,0], [0,0,1])

  return [swp1, swp2]
}

// From: https://en.wikipedia.org/wiki/Sagitta_(geometry)#Formulas
const sagittaRadius = (chordLength, arcHeight) => {
  const [l, s] = [chordLength, arcHeight]
  return s/2 + l*l/(8*s)
}
const sagittaChordLength = (radius, arcHeight) => {
  const [r, s] = [radius, arcHeight]
  return 2 * Math.sqrt(2*r*s - s*s)
}
const sagittaArcHeight = (chordLength, radius) => {
  const [l, r] = [chordLength, radius]
  return r - Math.sqrt(r*r - l*l/4)
}
const vec2dLength = (p) => Math.sqrt(p[0]*p[0] + p[1]*p[1])
const lineLength = (p1, p2) => vec2dLength([p1[0]-p2[0], p1[1]-p2[1]])

const connectorRailPair = (i) => {
  // const zOffset = ((numPairs - i) % numPairs) * deltaY - wireWidth/2
  const railHeight = wireWidth + vertTurns * 2*(wireWidth + wireGap) + (numPairs-1)*deltaY
  const railAngleDelta = Math.PI / numPairs

  const railInnerRadius = innerRadius + numPairs*(wireWidth + wireGap)
  const innerDeltaTheta = Math.asin(wireGap / (2*railInnerRadius))
  const innerStartPoint = [railInnerRadius,0]
  const innerEndAngle = railAngleDelta - 2*innerDeltaTheta
  const innerEndPoint = [railInnerRadius*Math.cos(innerEndAngle),railInnerRadius*Math.sin(innerEndAngle)]
  const innerArcHeight = sagittaArcHeight(lineLength(innerStartPoint,innerEndPoint), railInnerRadius)

  const railOuterRadius = railInnerRadius + wireWidth
  const outerDeltaTheta = Math.asin(wireGap / (2*railOuterRadius))
  const outerStartPoint = [railOuterRadius,0]
  const outerEndAngle = railAngleDelta - 2*outerDeltaTheta
  const outerEndPoint = [railOuterRadius*Math.cos(outerEndAngle),railOuterRadius*Math.sin(outerEndAngle)]
  const outerArcHeight = sagittaArcHeight(lineLength(outerStartPoint,outerEndPoint), railOuterRadius)

  const makeRail = (rotation) => r.draw()
    .movePointerTo(outerStartPoint)
    .sagittaArcTo(outerEndPoint, -outerArcHeight)
    .lineTo(innerEndPoint)
    .sagittaArcTo(innerStartPoint, innerArcHeight)
    .close()
    .sketchOnPlane()
    .extrude(railHeight)
    .translateZ(-wireWidth/2)
    .rotate(rotation)

  const rail1 = makeRail(i*180/numPairs)
  const rail2 = makeRail(180 + i*180/numPairs)

  return [rail1, rail2]
}

const main = () => {
  const shapes = []

  for (let i = 0; i < numPairs; i++) {
    shapes.push(...coilPair(i))
    shapes.push(...connectorRailPair(i))
  }
  
  if (fuseAll) {
    let final = shapes[0]
    for (const shape of shapes.slice(1)) { final = final.fuse(shape) }
    return final
  }
  return shapes
}

[gmlewis]

I'm realizing now that I don't actually want a "frenet" helix.
What I really want is to make my own parameterized curve where I control the "tangent", "normal" and "right" (aka "binormal" ) unit vectors myself. That way, I can make sure that the "tangent" vector is always perfectly horizontal instead of bending along the actual curve.

I actually had to do this before for Blackjack: https://github.com/gmlewis/blackjack/blob/gmlewis-master/blackjack_lua/run/helix.lua

[raydeleu]

I assume that if you use the solution I presented earlier #125 (comment), where the helix is constructed as a loft through sections positioned along the helix, you would have complete control over each angle of these sections. With the pivot command you can angle the plane on which you project your section and you can even 2D rotate and translate the section on that plane if you want.

[gmlewis]

That is actually a very similar solution to Blackjack's, interestingly enough.

[gmlewis]

I've gone through the docs and have not found a way to create a fully parametric curve in 3D space.

[sgenoud]

This is the closest function that I expose: https://replicad.xyz/docs/api/#makebsplineapproximation

Note that you would not have the parametric curve, but an approximation (and you would need to map between your parametric function and a set of points).

Not sure it would 100% help (especially as the parametric function is not by itself a primitive in the CAD kernel).