Bug: Kernel error when `fuse()`ing a straight cylinder with one made with `genericSweep()`

[danfuzz]

[As with issue #221, this is presumably a bug in the underlying OpenCASCADE library, but I don't know how to translate my findings here to that level.]

I ran into a modeling issue where fusing a straight cylinder with a curved cylinder made from one created by genericSweep()ing will work when fusing via straightTube.fuse(curveTube) but not curveTube.fuse(straightTube). The latter causes a "kernel error."

I tried simplifying my test case as much as I could, and here's where I landed. You'll note that I'm making the straightTube in a bit of a convoluted way (extruding along the "wrong" axis and then rotating it into position), which is an artifact of the non-test-case that I started with. (I tried extruding it in a more straightforward way but was unable to reproduce the bug after that cleanup.)

const {
  assembleWire,
  drawCircle,
  genericSweep,
  makeCircle,
  makeLine,
  makeTangentArc
} = replicad;

const TUBE_RADIUS     = 20;
const STRAIGHT_LENGTH = 70;
const ARC_ARM_LENGTH  = 19;
const ARC_RADIUS      = 25;

const ARC_FULL_LENGTH = ARC_ARM_LENGTH + ARC_RADIUS;

function addPoints(point1, point2) {
  const [x1, y1, z1] = point1;
  const [x2, y2, z2] = point2;

  return [x1 + x2, y1 + y2, z1 + z2];
}

function makeStraightTube() {
  return drawCircle(TUBE_RADIUS)
    .sketchOnPlane('YZ')
    .extrude(STRAIGHT_LENGTH)
    .rotate(90);
}

function makeCurveTube() {
  // Note: `genericSweep()` gets confused if the `path` wire doesn't start at the origin.
  const arcStartPoint = [0, 0, 0];
  const arcTangentPoint = addPoints(arcStartPoint, [ARC_RADIUS, 0, 0]);
  const arcEndPoint     = addPoints(arcTangentPoint, [0, -ARC_RADIUS, 0]);
  const endPoint        = addPoints(arcEndPoint, [0, -ARC_ARM_LENGTH, 0]);

  const path = assembleWire([
    makeTangentArc(arcStartPoint, arcTangentPoint, arcEndPoint),
    makeLine(arcEndPoint, endPoint)
  ]);

  const section   = assembleWire([makeCircle(TUBE_RADIUS)]);
  const sweepOpts = { transitionMode: 'round' };
  const shape     = genericSweep(section, path, sweepOpts, false);

  // `translate()` to move the circle-center of the arc to the origin, and then
  // `rotate()` to put it in the x-z plane instead of the x-y plane.
  return shape
    .translate(-ARC_RADIUS, ARC_FULL_LENGTH, 0)
    .rotate(90, [0, 0, 0], [0, 1, 0]);
}

function main()
{
  const straightTube = makeStraightTube();
  const curveTube    = makeCurveTube();

  // Uncomment this to see a version that works.
  return straightTube.fuse(curveTube);

  return curveTube.fuse(straightTube);
}

For reference, here's what the shape looks like when correctly fused:

[danfuzz]

Probably related to this bug, I ran into another case where a problem is caused by two curved (arc segment) tubes getting fuse()d such that one of the ends of each tube exactly overlap each other. In this case, the result looks as if the fuse didn't do anything at all, however if you use the result ultimately things get wonkier and wonkier.

I found that if I translate() the two tubes just slightly, the problem goes away. Here's a stripped down example where you can turn on and off the translate() workaround:

const {
  assembleWire,
  genericSweep,
  makeCircle,
  makeTangentArc
} = replicad;

const ARC_RADIUS  = 25;
const TUBE_RADIUS = 10;

function addPoints(point1, point2) {
  const [x1, y1, z1] = point1;
  const [x2, y2, z2] = point2;

  return [x1 + x2, y1 + y2, z1 + z2];
}

function makeCurve(xyFudge) {
  const section = assembleWire([
    makeCircle(TUBE_RADIUS)
  ]);

  // Note: `genericSweep()` gets confused if the wire doesn't start at the
  // origin.
  const startPoint   = [0, 0, 0];
  const tangentPoint = addPoints(startPoint, [ARC_RADIUS, 0, 0]);
  const endPoint     = addPoints(tangentPoint, [0, -ARC_RADIUS, 0]);

  const path = assembleWire([
    makeTangentArc(startPoint, tangentPoint, endPoint)
  ]);

  const sweepOpts = {
    forceProfileSpineOthogonality: true,
    transitionMode: 'round'
  };

  const shape = genericSweep(section, path, sweepOpts, false);

  return shape
    .translate(-ARC_RADIUS - xyFudge, -xyFudge, 0);
}

const defaultParams = { workaround: false };

function main(replicad_unused, { workaround }) {
  // Experimentally, this is approximately the minimum amout of fudge needed for
  // a `translate()` that will make the `fuse()` work.
  const WORKAROUND_FUDGE = 0.00010059874;

  const xyFudge = workaround ? WORKAROUND_FUDGE : 0;
  const curve1  = makeCurve(xyFudge);
  const curve2  = makeCurve(xyFudge).rotate(-90);

  return curve1.fuse(curve2);
}

Expected result (result with workaround):

Actual result (without workaround):

[sgenoud]

It looks like you found by yourself the generic way to solve these issues (wiggling stuff around). It is definitely not very satisfactory - but the problems are upstream.

Do you mind if I move these to discussions? I think they can be useful to point to when people have similar issues (and they are not really fixed issues, more ways to deal with the kernel).

[danfuzz]

Do you mind if I move these to discussions?

@sgenoud Fine by me.

At this point, I'm hoping upstream Open Cascade JS can get fixed (synched to its own upstream etc.) sooner rather than later. This is definitely a frustrating situation to (repeatedly) find myself in.