[oursland]

Port of boolean.topology_intersector_p3: SmTopologyIntersector::MergeCurveClasses, MergeCurveOnSurfaces and MergeCoincidentSurfaces, with shim, FFI, difftest runner and report. Status partial.

Dependencies

All on main now: #146 and #203 (parts 1 and 2), #85 (intersect.curve_class_p2) and #137 (intersect.curve_class_p4). The branch is up to date with main at e4dd81c4.

The port

All three functions are ported in full. There is a stub at each call into a unit that is still todo, with the upstream logic after it:

• topology.face_p4: GetEdges, GetUpwardLoopuses;
• topology.brep_p4: DeleteEdge.

query.face_p1 is partial, so its calls are wired. SmFace::Point3DClassify and CalculateBoundingBox (bTight = FALSE) are IntersectorBrepP3 hooks, and the difftest adapter implements them with query::face::p1. Upstream passes the double dCurveTolerance where an SmZoneTol3d is expected, in the classify call and the SmPointClassification constructor. The port applies zone_tol3d at both, as that implicit conversion does.

IntersectorBrepP3 extends IntersectorBrepP2 and adds the surface, edge, loop-use, edge-use and face-use walks. Out-params become return values. Temporary curves are stored for a handle and reported for the caller to free.

Changes outside the unit

• curve_class_p4: its ReSet, ConnectIntervals and GetMinUV / GetMaxUV stubs are wired to part 2. They are still stubs on main, because port: intersect.curve_class_p2 #85 and port: intersect.curve_class_p4 #137 merged separately.
• curve_class_p1: sm_MakeConsistentClassifications was a stub on topology.edge, which is already partial. It is now ported in full, through ClassGeometry::topology_entity and a new default method ClassGeometry::topology_handle_in.
• curve_class_p7:
  • SmEdge::GetCurve / GetInterval and the edge-pair tolerance are wired the same way where classification geometry is in scope.
  • Bug fix: TestForPartialCoincidentEdges now copies the B-spline base of a coincident edge curve of any type derived from SmBSplineCurve (SmLine, SmEllipse/SmCircle, SmHyperbola, SmParabola), as SM_CAST_PTR does. Before, it rejected everything but a plain B-spline. This unit's fuzz found it: 3 inputs where C++ returned SM_ERR and Rust a null-dereference error. curve_class_p7's own difftest is unchanged.
• Adapters without topology hooks (e.g. the curve_class_p7 runner's stand-in edges) keep the previous Unported deferral, so no runner's outcome flips to a failure.
• curve_class_p4 shim: refuses GetLoopCrossings on an empty classification. A squeeze can now empty one, and upstream then reads GetAt(0) unchecked.
• topology.brep_p2 runner: its Merge cases classify through MergeObjects, which names only the case's curves: every face, edge and vertex is one placeholder handle without geometry. With ReSet wired, the fixture case merge_plane10_line (smTopoTest.cpp:1664) gets past the ReSet stub it deferred on and needs a face's geometry. It now defers under harness:merge-objects, a gap of that runner, not of the port. That unit is at 1709 / 1437 / 0 / 272.
• port: boolean.topology_intersector_p1 #146's runner and FFI: visibility only (pub(super)), plus the two topology hooks on its Two adapter and blocks_len.

Back-edges

• blend.fillet_geom_p4's MergeCurveOnSurfaces stub is retagged blend.fillet_executive_p1. It runs on the fillet executive's intersector, which that unit provides; its RegisterExistingSSI stub is already tagged the same way.
• boolean.merge_p1's MergeCoincidentSurfaces stays UNPORTED(boolean.topology_intersector_p3). Wiring it needs two things: an IntersectorBrepP3 implementation for boolean.merge_p4's ArenaPair, and fix_face_coincidence taking the kernels and notification context. That is cross-unit work, so it is left for a follow-up PR (noted in plan/modules.toml and plan/findings.md).

Harness note

The shared B-rep import keeps vertex uses in arena order, not upstream's list order, so GetEdges can come out in a different order. This unit's runner reads the list order from its shim and reorders the imported lists. Details are in plan/findings.md; exporting the order in sc_topology_fixture.h would fix every runner at once.

Difftest (linux/arm64 container)

PARTIAL boolean.topology_intersector_p3 cases=267 passed=143 failed=0 deferred=124 max_rel_err=0e0 with_values=143 no_values=0 blocked_by=intersect.curve_class_p6(44),topology.brep_p1(4),topology.brep_p3(4),topology.edge(36),topology.face_p4(28),topology.vertex(8)
SENSITIVE boolean.topology_intersector_p3 perturbed=143 detected=143 unperturbed=0 deferred=124
FUZZ-PASS boolean.topology_intersector_p3 cases=2000 rejected=376 malformed=653 ran=971 differs=0 crashes=0 panics=0 timeouts=0
PARTIAL boolean.topology_intersector_p1 cases=830 passed=693 failed=0 deferred=137
PARTIAL boolean.topology_intersector_p2 cases=841 passed=667 failed=0 deferred=174
PARTIAL intersect.curve_class_p1 cases=2125 passed=2048 failed=0 deferred=77
PARTIAL intersect.curve_class_p4 cases=3201 passed=2222 failed=0 deferred=979   (1318 passed on main)
PARTIAL intersect.curve_class_p7 cases=1516 passed=1077 failed=0 deferred=439
PARTIAL query.face_p1 cases=2224 passed=1570 failed=0 deferred=654
PARTIAL blend.fillet_geom_p4 cases=398 passed=362 failed=0 deferred=36
PARTIAL topology.proto_topology_p3 cases=3013 passed=2638 failed=0 deferred=375
PARTIAL boolean.merge_p1 cases=248 passed=203 failed=0 deferred=45
PARTIAL boolean.merge_p4 cases=311 passed=30 failed=0 deferred=278
PARTIAL topology.brep_p2 cases=1709 passed=1437 failed=0 deferred=272
--green: 235 unit(s), 113 passed, 118 partial, 4 failed

The topology.brep_p1 / brep_p3 deferrals are topology.brep_p5's own stubs (m_bEditingEnabled, SqueezeEdge), reached through CombineCoincidentVertices when squeezing.

The 4 --green failures are the arm64 conversion difference already in plan/findings.md, not a regression. They are heal.heal_data_p1 3, _p2 123, _p3 7 and geom.hash_table 435. CI's x86-64 run of this branch merged into main passed all four. The container runs linux/arm64, and upstream's out-of-range double→ULONG conversions differ from x86-64, which the port follows.

• main (bb137d7d) gives 3 / 104 / 7 / 435 in the same container.
• This branch lets the healer reach code behind part 4's wired calls: 4 generated heal_data_p2 cases that main defers now run (gen0070, gen0211, gen0544, gen0549).
• With the two Rust conversions switched to arm64's saturating semantics for the experiment, heal.heal_data_p2 passes every case it runs (452, 0 failed). So these 4 pass on x86-64 CI.

fmt (including rustfmt --edition 2021 on the include!d runner), clippy (--workspace --all-targets, with and without difftest/cpp), the 1526 kernel tests and the wasm32 check pass.

🤖 Generated with Claude Code

[tangency-monitor]

Thanks @oursland, this is a big, careful port. I reviewed head dfa56606 against SmTopologyIntersector.cpp (MergeCurveClasses 3001-3889, MergeCurveOnSurfaces 3915-4329, MergeCoincidentSurfaces 4347-4891) and sm_MakeConsistentClassifications (SmCurveClass.cpp 3048-3275).

What passed

• cargo fmt --all --check, clippy -D warnings (plain and with solidcore-ffi/cpp,difftest/cpp), cargo test -p solidcore (1526 passed), wasm32 check. The branch merges cleanly into current main (0a676a04, 83 commits ahead).

• The port follows upstream closely in every branch I traced. Examples: eSqueezeStat carries across iterations, the start-vertex block only checks deleted edges while the end block also checks deleted vertices, and the edge repair keeps upstream's GetBrepMate(pE1) in the second branch. The deleted lists stay untouched on the early SM_SUCCESS returns and are replaced on each MergeCurveClasses. The two sEdgesB / lOEdgesCount edge-count baselines in MergeCoincidentSurfaces differ, as upstream's do. The SM_CAST_PTR(SmBSplineCurve, ..) fix in p7 is correct: SmLine, SmEllipse/SmCircle, SmHyperbola and SmParabola derive from SmBSplineCurve, and SmConic does not.

• 488 extra adversarial cases through difftest. All 8 fixture files were covered, with these inputs:

  • surfaces without edges, so the CurveOnClassify / SetIntersectData path runs;
  • one edge plus one surface, and both surfaces plus both edges;
  • tolerances 1e-15, 1e-6, 1e-2 and 1e3, so the degenerate Point3DClassify / MergeIntoObject path runs;
  • mismatched edges with ignore_tangency;
  • cross-file coincident surfaces;
  • short sub-range classifications that hit the / 20.0 skip;
  • vertex/edge end mixes with and without merge_singularities;
  • face-mid classifications.

  487 ran: 242 passed, 245 deferred, 0 failed. One crashed the C++ side (must-fix 1).

PARTIAL boolean.topology_intersector_p3 cases=267 passed=143 failed=0 deferred=124 max_rel_err=0e0 with_values=143 no_values=0 blocked_by=intersect.curve_class_p6(44),topology.brep_p1(4),topology.brep_p3(4),topology.edge(36),topology.face_p4(28),topology.vertex(8)
difftest: 235 unit(s), 114 passed, 121 partial, 0 failed   (--green, x86-64)
extra cases (local, by file group): 487 ran, 242 passed, 245 deferred, 0 failed; 1 SIGSEGV in C++ (below)

Must-fix

1. The shim segfaults on a classification that the FFI and the runner accept.

   • Location: harness/cpp/shim/boolean_topology_intersector_p3.cpp:263 (spec_ok) and crates/difftest/src/units/boolean_topology_intersector_p3.rs:509 (class_ok).
   • Input: box_with_large_fillet.smb twice, merge: curve_classes. Each side has curve = [b,3,0], f0 = 0.25, f1 = 0.75, start and end SM_PC_UNKNOWN with a null object, and mid SM_PC_FACE on [b,2,0].
   • Result: difftest dies with SIGSEGV in SmCurveClassification::MergeInterval, called from MergeClassifications and MergeCurveClasses. The whole --unit / --green run is lost.
   • Cause: upstream SmCurveClass.cpp:17320 tries sm_ComputeFacePointClass for the Unknown end of a face-mid interval. When the point does not project onto that face, the end stays Unknown with no object. pStartV is then NULL, and it is dereferenced at :17659 (pStartV->GetPoint(), where both ends are NULL) or at :17672 (pStartV->GetBrep()).
   • Fix: in both spec_ok and class_ok, refuse an SM_PC_UNKNOWN start or end whose interval mid is SM_PC_FACE or SM_PC_REGION. Report it as NULL_DEREF, as for the other refused inputs, and add this case as an inline edge case. If you want those inputs kept, the exact guard is to run the same face projection first. A face-mid class with vertex ends ran fine in all 8 files.
   • Why the fuzz missed it: gen_class only generates SM_PC_EDGE mids.

2. rustfmt --edition 2021 --check fails on the new include!d FFI file. crates/solidcore-ffi/src/units/boolean_topology_intersector_p3.rs has diffs at lines 161, 318 and 339. cargo fmt does not see include!d files, so CI passes. Fix: run rustfmt --edition 2021 on that file. The runner file is already clean.

Should-fix (short)

• boolean.merge_p1 still has UNPORTED(boolean.topology_intersector_p3) (crates/solidcore/src/boolean/merge/p1.rs:186) now that this unit is partial. You documented why, and every path through MergeCoincidentSurfaces defers on topology.face_p4 (GetEdges) today, so no compared case is lost. Please open a tracking issue (or reference one in the notes) so that wiring the ArenaPair adapter is not forgotten.
• MergeCurveOnSurfaces is never compared with UV curves. The shim passes nullptr for pUVCurve1 / pUVCurve2, and the runner passes None, so uv_curve1 / uv_curve2 reach the classifications untested. One fixture case with a dropped UV curve would cover it.
• Owner of the curve copies in MergeCoincidentSurfaces. Upstream sets the owner (the edge) on pECopy (SmTopologyIntersector.cpp:4484, :4662/:4666) but not on the per-UV pECopy2. SmTol::GetZoneTol3d(curve) and SmCurve::GetEdge read that owner. The port uses edge_curve.clone() for both (p3.rs:1522, :1616). Whether the clone carries the arena curve's owner decides which of the two it matches. This is unreachable until topology.face_p4 lands; worth a line in the Deviations entry so the next porter checks it.

Notes

• #316 (opened later) rewires the same p7 helpers (edge_pair_xsect_tol_3d, as_b_spline, edge_interval). git merge-tree shows conflicts in p7.rs, plan/modules.toml and the curve_class_p4 report, so whichever lands second will need to reconcile. No action is needed here.
• The new UNPORTED(topology.edge) / UNPORTED(topology.vertex) fallbacks in p1/p7 cover adapters that cannot resolve a handle, the same pattern as object_zone_tol_3d on main. That is fine.

🤖 Generated with Claude Code