SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 39/45: diagnostics.kernel takes a typed contract, as main's other diagnostics commands do
jyviko28e983e191ea
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.ymlindex 1e6eb58063..513596eade 100644--- a/.github/workflows/ci.yml+++ b/.github/workflows/ci.yml@@ -442,9 +442,6 @@ jobs:with:key: quick-compilesave-if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh- name: Cargo checkrun: cargo check --workspace --all-targets --locked@@ -464,9 +461,6 @@ jobs:with:key: native-clippysave-if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh- name: Clippyenv:FULL: ${{ needs.changes.outputs.full }}@@ -476,6 +470,13 @@ jobs:scope=(--workspace)if [ "$FULL" != true ]; then scope=(); for p in $PACKAGES; do scope+=(-p "$p"); done; ficargo clippy "${scope[@]}" --all-targets --profile ci --locked -- -D warnings+ # The C++ SMLib kernel is opt-in (`--features smlib`, off by default): lint the code and tests+ # behind it too, on the crates that have any. Needs the prebuilt library.+ - name: Fetch SMLib (crates/smlib/SMLIB_REV)+ shell: bash+ run: scripts/fetch-smlib.sh+ - name: Clippy with the C++ SMLib kernel+ run: cargo clippy -p solidcraft-smlib -p solidcraft-kernel -p solidcraft-cli --features solidcraft-cli/smlib --all-targets --profile ci --locked -- -D warningsbuild-tests:name: Build tests@@ -510,9 +511,6 @@ jobs:with:key: native-testssave-if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh- name: Set up compiler cacheuses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11with:@@ -584,9 +582,6 @@ jobs:with:key: native-testssave-if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh- name: Set up compiler cacheuses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11with:@@ -640,6 +635,69 @@ jobs:path: ${{ env.CARGO_TARGET_DIR || 'target' }}/nextest/ci/junit.xmlretention-days: 7+ cpp-tests:+ name: Native Linux tests (C++ SMLib)+ # The tests that compare solidcore with the C++ SMLib kernel (parity tests, the C++ round trips,+ # the C++ SSI corpus score, the model cache across kernels) are built only with the opt-in+ # `smlib` feature, which every other job leaves off. They live in solidcraft-smlib,+ # solidcraft-kernel and the CLI's model_cache; the other tests there run again here on+ # solidcore, the default kernel either way, graded against the same list.+ needs: changes+ if: ${{ !cancelled() && needs.changes.result == 'success' && needs.changes.outputs.native == 'true' }}+ runs-on: blacksmith-16vcpu-ubuntu-2404+ timeout-minutes: 60+ env:+ CARGO_INCREMENTAL: "0"+ RUSTC_WRAPPER: sccache+ SCCACHE_DIR: /home/runner/.cache/sccache+ SCCACHE_CACHE_SIZE: 20G+ steps:+ - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1+ - name: Size parallel compiles to the job's memory+ run: scripts/ci/build-jobs.sh+ - uses: dtolnay/rust-toolchain@stable+ - name: Mount the compiler cache+ uses: useblacksmith/stickydisk@3f6be1451e3cad893b778bc93495c80452a5da26 # v1.7.2+ continue-on-error: true+ with:+ key: ${{ github.repository }}-sccache-cpp-tests+ path: /home/runner/.cache/sccache+ commit: ${{ github.ref == 'refs/heads/main' && 'on-change' || 'false' }}+ - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2+ with:+ key: native-cpp-tests+ save-if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' }}+ - name: Fetch SMLib (crates/smlib/SMLIB_REV)+ shell: bash+ run: scripts/fetch-smlib.sh+ - name: Set up compiler cache+ uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11+ with:+ version: v0.16.0+ - uses: taiki-e/install-action@1168f6810a3cb30a3514bf5756a3b7f0422c6df8 # v2.87.28+ with:+ tool: cargo-nextest+ - name: Run the tests with the C++ kernel built+ env:+ EVENT_NAME: ${{ github.event_name }}+ run: |+ # The pull request filter of Native Linux tests (default() in .config/nextest.toml);+ # elsewhere everything but the random boolean property tests, as there.+ base='default()'+ if [ "$EVENT_NAME" != pull_request ]; then+ base='not (package(solidcraft-kernel) & binary(boolean_props))'+ fi+ junit=${CARGO_TARGET_DIR:-target}/nextest/ci/junit.xml+ rm -f "$junit"+ status=0+ cargo nextest run -p solidcraft-smlib -p solidcraft-kernel -p solidcraft-cli --features solidcraft-cli/smlib \+ --cargo-profile ci --locked --profile ci --no-tests=pass --ignore-default-filter -E "($base) & (not package(=solidcraft-cli) | binary(=model_cache))" || status=$?+ if [ "$status" -ne 0 ] && [ "$status" -ne 100 ]; then exit "$status"; fi+ cargo xtask known-failing --junit "$junit"+ - name: Compiler cache statistics+ if: always()+ run: sccache --show-stats+gpu-path-tests:name: GPU path tests (${{ matrix.shard }}/4)# The GPU path tracer's tests (about 108) compile their pipelines on lavapipe, one test at a@@ -703,9 +761,6 @@ jobs:with:key: native-gpusave-if: ${{ (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop') && matrix.shard == 1 }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh- name: Set up compiler cacheuses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11with:@@ -862,9 +917,6 @@ jobs:with:key: doc-testssave-if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh- name: Set up compiler cacheuses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11with:@@ -923,9 +975,6 @@ jobs:with:key: oraclesave-if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh- name: Set up compiler cacheuses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11with:@@ -965,9 +1014,6 @@ jobs:with:key: windows-fxcsave-if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh# One test at a time: WARP's shader JIT crashes now and then (a null read in# d3d10warp.dll's JIT optimizer, about 1 run in 60) when several devices compile compute# pipelines at once, which the parallel tests do. Minidumps showed it in WARP itself, not@@ -992,9 +1038,6 @@ jobs:with:key: windows-startupsave-if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh- name: Backend order and probing on Windowsrun: cargo test -p solidcraft --profile ci --locked -- startup::tests native_crash::tests native_frame::tests- name: Build the app@@ -1012,7 +1055,7 @@ jobs:# commit's real run instead: the merge queue reads `ci` from the newest run of a commit, so a# run without a passing `ci` would block a pull request that passed (#1850, #3182, #3252).name: ci- needs: [changes, checks, quick-compile, clippy, build-tests, tests, gpu-path-tests, doc-tests, oracle, windows-fxc, windows-startup, dependency-advisories, wasm]+ needs: [changes, checks, quick-compile, clippy, build-tests, tests, cpp-tests, gpu-path-tests, doc-tests, oracle, windows-fxc, windows-startup, dependency-advisories, wasm]if: always() && (github.event_name != 'pull_request' || !github.event.pull_request.draft)runs-on: blacksmith-2vcpu-ubuntu-2404permissions:@@ -1060,6 +1103,7 @@ jobs:BUILD: ${{ needs.build-tests.result }}EVENT_NAME: ${{ github.event_name }}TESTS: ${{ needs.tests.result }}+ CPP_TESTS: ${{ needs.cpp-tests.result }}GPU_RUN: ${{ needs.changes.outputs.gpu }}GPU: ${{ needs.gpu-path-tests.result }}DOCS: ${{ needs.doc-tests.result }}@@ -1084,6 +1128,7 @@ jobs:test "$BUILD" = successfitest "$TESTS" = success+ test "$CPP_TESTS" = successfi# The same output decides whether the GPU path tests run (their job's `if`).if [ "$GPU_RUN" = true ]; then@@ -1132,9 +1177,6 @@ jobs:with:key: wasmsave-if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh wasm32-unknown-unknown- run: cargo xtask wasmriscv64-gates:@@ -1157,9 +1199,6 @@ jobs:with:key: riscv64save-if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh riscv64gc-unknown-linux-gnu- name: Install cross-compilation dependenciesrun: |# Ubuntu's regular archive serves amd64; RISC-V packages live in ports.@@ -1180,8 +1219,6 @@ jobs:- name: Cargo check on RISC-Venv:CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_LINKER: riscv64-linux-gnu-gcc- # SMLib has no prebuilt library for RISC-V: its sources are compiled with this.- CXX_riscv64gc_unknown_linux_gnu: riscv64-linux-gnu-g++PKG_CONFIG_SYSROOT_DIR: /PKG_CONFIG_PATH: /usr/lib/riscv64-linux-gnu/pkgconfig:/usr/share/pkgconfigPKG_CONFIG_ALLOW_CROSS: 1diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.ymlindex cf1c396915..0e7d17e09c 100644--- a/.github/workflows/docker.yml+++ b/.github/workflows/docker.yml@@ -53,9 +53,6 @@ jobs:with:key: docker-websave-if: ${{ github.ref == 'refs/heads/main' }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh wasm32-unknown-unknown- name: Install trunkrun: |mkdir -p "$HOME/.local/bin"diff --git a/.github/workflows/external-corpus.yml b/.github/workflows/external-corpus.ymlindex 8267eff1f6..f43515a607 100644--- a/.github/workflows/external-corpus.yml+++ b/.github/workflows/external-corpus.yml@@ -29,9 +29,6 @@ jobs:steps:- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1- uses: dtolnay/rust-toolchain@stable- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh- name: Build the CLIrun: cargo build --profile ci -p solidcraft-cli- name: Import and check every entrydiff --git a/.github/workflows/fillet-rig.yml b/.github/workflows/fillet-rig.ymlindex 57098f1134..cb02ca966b 100644--- a/.github/workflows/fillet-rig.yml+++ b/.github/workflows/fillet-rig.yml@@ -1,7 +1,7 @@# The fillet rig as a regression gate: a pull request that touches fillet code (the paths below)-# runs every case in tests/kernel-cases/fillets/ on SMLib, through one release build of+# runs every case in tests/kernel-cases/fillets/ on solidcore, through one release build of# solidcraft-cli, and fails on a regression (a case that fails and-# tests/kernel-cases/fillets/KNOWN_FAILING does not list) or on a listed case that now passes+# tests/kernel-cases/fillets/KNOWN_FAILING.solidcore does not list) or on a listed case that now passes# (it is fixed: remove its line, so the list only shrinks). See tests/kernel-cases/README.md.## GitHub filters a workflow by whole files, so the fillet parts of crates/doc/src/eval*.rs and@@ -86,20 +86,17 @@ jobs:with:key: fillet-rigsave-if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop' }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh- name: Set up compiler cacheuses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11with:version: v0.16.0- - name: Build the CLI (release, SMLib)- run: cargo build --release --locked -p solidcraft-cli --features smlib+ - name: Build the CLI (release, solidcore alone)+ run: cargo build --release --locked -p solidcraft-cli- name: Run the fillet cases against the known-failing listrun: >-cargo run -q --locked -p xtask -- kernel-cases --area fillets--cli target/release/solidcraft-cli --out "$RUNNER_TEMP/fillet-rig"- --known-failing tests/kernel-cases/fillets/KNOWN_FAILING+ --known-failing tests/kernel-cases/fillets/KNOWN_FAILING.solidcore- name: Keep the resultsif: always()uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2diff --git a/.github/workflows/generated.yml b/.github/workflows/generated.ymlindex abe627d32b..b70b1338a8 100644--- a/.github/workflows/generated.yml+++ b/.github/workflows/generated.yml@@ -48,9 +48,6 @@ jobs:- uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2with:key: generated-files- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh- name: THIRD-PARTY-LICENSES.txtrun: cargo xtask licences- name: docs/features.mddiff --git a/.github/workflows/kernel-rig.yml b/.github/workflows/kernel-rig.ymlindex ba811a7fb6..4b1c48e13c 100644--- a/.github/workflows/kernel-rig.yml+++ b/.github/workflows/kernel-rig.yml@@ -7,8 +7,8 @@# matrix of shards as an artifact, one per selected area plus the ladder, in parallel, so the# wall time is the build plus the slowest shard. See tests/kernel-cases/README.md.#-# - An area fails on a regression (a case that fails and its tests/kernel-cases/<area>/KNOWN_FAILING-# does not list) or on a listed case that passes (it is fixed: remove its line in the same pull+# - An area, on solidcore, fails on a regression (a case that fails and its+# tests/kernel-cases/<area>/KNOWN_FAILING.solidcore does not list) or on a listed case that passes (it is fixed: remove its line in the same pull# request, so the list only shrinks).# - The ladder fails on any case whose status or counts differ from# tests/kernel-cases/ladder/golden.json; a right change is re-recorded (`--record "why"`).@@ -199,9 +199,11 @@ jobs:SHARD: ${{ matrix.shard }}run: |if [ "$SHARD" = ladder ]; then- set -- --ladder --gate+ # The golden is the C++ kernel's: solidcore differs on one case (shell under mitred+ # rounds), so this shard stays on it until a solidcore golden is justified.+ set -- --ladder --gate --kernel smlibelse- set -- --area "$SHARD" --known-failing "tests/kernel-cases/$SHARD/KNOWN_FAILING"+ set -- --area "$SHARD" --known-failing "tests/kernel-cases/$SHARD/KNOWN_FAILING.solidcore"fitarget/debug/xtask kernel-cases "$@" --cli target/release/solidcraft-cli --out "$RUNNER_TEMP/kernel-rig"- name: Keep the results@@ -209,7 +211,7 @@ jobs:uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2with:name: kernel-rig-results-${{ matrix.shard }}- path: ${{ runner.temp }}/kernel-rig/results.json+ path: ${{ runner.temp }}/kernel-rig/**/results.jsonif-no-files-found: ignore# One check for the whole gate, for branch protection and the merge queue.diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.ymlindex ea87218cd3..02c2c02002 100644--- a/.github/workflows/pages.yml+++ b/.github/workflows/pages.yml@@ -41,9 +41,6 @@ jobs:with:targets: wasm32-unknown-unknown- uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh wasm32-unknown-unknown- name: Install mdbook and trunkrun: |mkdir -p "$HOME/.local/bin"diff --git a/.github/workflows/release.yml b/.github/workflows/release.ymlindex 5882ba943a..007de0fab8 100644--- a/.github/workflows/release.yml+++ b/.github/workflows/release.yml@@ -126,9 +126,6 @@ jobs:- uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2with:key: release-icons- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh- run: cargo build --release --locked -p solidcraft-cli- run: |. packaging/env.sh@@ -168,9 +165,6 @@ jobs:- uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2with:key: release-linux-${{ matrix.arch }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh- name: Build and package (AppImage, deb, rpm, tar.gz)run: packaging/linux/package.sh- name: Check the packages@@ -395,9 +389,6 @@ jobs:- uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2with:key: release-macos-${{ matrix.arch }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh ${{ matrix.target }}- name: Buildrun: packaging/macos/package.sh --build-only ${{ matrix.target }}# Not named release-*: the release job collects every release-* artifact as an asset.@@ -496,9 +487,6 @@ jobs:- uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2with:key: release-windows-${{ matrix.arch }}- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh ${{ matrix.target }}- name: Install WiXshell: pwshrun: |@@ -630,9 +618,6 @@ jobs:- uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2with:key: release-web- - name: Fetch SMLib (crates/smlib/SMLIB_REV)- shell: bash- run: scripts/fetch-smlib.sh wasm32-unknown-unknown- name: Install trunkrun: |curl -fsSL "https://github.com/trunk-rs/trunk/releases/download/v${TRUNK_VERSION}/trunk-x86_64-unknown-linux-gnu.tar.gz" \diff --git a/ATTRIBUTION.md b/ATTRIBUTION.mdindex e41401c438..285c577764 100644--- a/ATTRIBUTION.md+++ b/ATTRIBUTION.md@@ -811,6 +811,15 @@ in THIRD-PARTY-LICENSES.txt; no images or artwork from that project are copied.The glTF test files are built by the tests themselves (crates/io/src/gltf_in_tests.rs,crates/engine/src/tests/gltf_import.rs); no third-party models are committed.+## Geometry kernel crates++| Crate | Used for | Licence |+|---|---|---|+| solidcore (https://github.com/tangency-labs/solidcore, pinned by rev in Cargo.toml) | the Rust port of NVIDIA's SMLib: the second backend behind crates/smlib, which routes an operation to it once it matches the C++ kernel on the kernel-case rig (crates/smlib/src/route.rs) | Apache-2.0 (its NOTICE credits NVIDIA's USD BRep) |++Linked as a crate; no code from it is copied into SolidCraft. Its licence text and NOTICE go+into THIRD-PARTY-LICENSES.txt when `main` regenerates it.+## FreeCAD and Rhino import libraryFreeCAD `.FCStd` and Rhino `.3dm` files are read with [cadmpeg](https://github.com/cadmpeg/cadmpeg)@@ -826,6 +835,7 @@ copied into SolidCraft.| SolidCraft file | Original contribution | Licence ||---|---|---|| crates/ui-egui/src/viewport.rs (`nearest_quarter_turn`, `axis_view_orbit`) | N3MI-DG's [PR #101](https://github.com/bherbruck/solidcraft/pull/101): [minimal TOP/BOTTOM turns](https://github.com/bherbruck/solidcraft/commit/c28e780f52490784ef5886f094b9d3f6d10c3e3f) and [drag-to-orbit](https://github.com/bherbruck/solidcraft/commit/f30b30be6ecc4e2e6544a851243137c01a354934), adapted to the axis gizmo | MIT OR Apache-2.0 |+| crates/smlib/src/core/offset.rs (`draft`: the tilted planes and `SmBrep::LocalOperation`, the tail of the capi's `draft_faces`) | ablasik's `draft` in `crates/smlib/src/ffi/rs_ops2.rs` on [ablasik/solidcraft `app/solidcore-backend-on-develop`](https://github.com/ablasik/solidcraft/blob/9c7e8e31565e1823f0591b58e2967351c32af13f/crates/smlib/src/ffi/rs_ops2.rs), adapted to `core::offset`'s errors and checks | MIT OR Apache-2.0 |## Vendored third-party codediff --git a/Cargo.lock b/Cargo.lockindex 3087b7a66d..ef5c9e582c 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4051,6 +4051,14 @@ dependencies = ["serde",]+[[package]]+name = "solidcore"+version = "1.0.1"+source = "git+https://github.com/tangency-labs/solidcore?rev=2dbd88b6e9b858144609690eb2860e0beba27e54#2dbd88b6e9b858144609690eb2860e0beba27e54"+dependencies = [+ "thiserror 2.0.21",+]+[[package]]name = "solidcraft"version = "0.30.1"@@ -4281,6 +4289,7 @@ dependencies = ["flate2","log","serde_json",+ "solidcore","solidcraft-geom","solidcraft-profile","web-time",diff --git a/Cargo.toml b/Cargo.tomlindex f6566eb5fd..d35d6674f1 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -31,6 +31,11 @@ solidcraft-space-mouse = { path = "crates/space-mouse" }solidcraft-mcp = { path = "crates/mcp" }solidcraft-derive = { path = "crates/derive" }solidcraft-3dx-client = { path = "crates/threedx-client" }+# The Rust port of NVIDIA's SMLib (Apache-2.0), the kernel crates/smlib routes operations to once+# they reach parity (crates/smlib/src/route.rs). Pinned; move the rev on its own commit. For a+# local checkout, add `[patch."https://github.com/tangency-labs/solidcore"] solidcore = { path =+# "../solidcore/crates/solidcore" }` to a `.cargo/config.toml` outside the repository.+solidcore = { git = "https://github.com/tangency-labs/solidcore", rev = "2dbd88b6e9b858144609690eb2860e0beba27e54" }# test tooling: a dev-dependency only (xtask/src/layers.rs)solidcraft-testkit = { path = "crates/testkit" }diff --git a/apps/solidcraft-cli/Cargo.toml b/apps/solidcraft-cli/Cargo.tomlindex 258dd32f91..ed69dc559e 100644--- a/apps/solidcraft-cli/Cargo.toml+++ b/apps/solidcraft-cli/Cargo.toml@@ -20,11 +20,12 @@ name = "solvecraft-cli"path = "src/alias.rs"[features]-default = ["raytrace-cpu", "smlib", "profile"]+default = ["raytrace-cpu", "profile"]bundled-render-library = ["solidcraft-engine/bundled-render-library"]raytrace-cpu = ["solidcraft-engine/raytrace-cpu"]-# Link SMLib into the kernel (solidcraft-engine/smlib; needs scripts/fetch-smlib.sh). SMLib is the-# only kernel, so without it the command line models nothing.+# Also link the C++ SMLib kernel (solidcraft-engine/smlib), off by default: needs a C++ toolchain+# and scripts/fetch-smlib.sh. solidcore, the Rust kernel, is always built and is the default either+# way; with this on, SOLIDCRAFT_KERNEL=smlib or the Geometry kernel preference can choose C++.smlib = ["solidcraft-engine/smlib"]# The profiler, compiled in so any build can say where its time goes (`--profile`,# SOLIDCRAFT_PROFILE=1); it records nothing until asked.diff --git a/apps/solidcraft-cli/src/kernel_cases.rs b/apps/solidcraft-cli/src/kernel_cases.rsindex dbe6e5343c..e1c9247525 100644--- a/apps/solidcraft-cli/src/kernel_cases.rs+++ b/apps/solidcraft-cli/src/kernel_cases.rs@@ -692,9 +692,12 @@ fn check_case(dir: &str, dumps: Option<&std::path::Path>, validation: solidcraftreturn out;}};- if !solidcraft_engine::kernel::smlib_built() {+ // The C++ kernel is needed only if it is the one asked for.+ if !solidcraft_engine::kernel::smlib_built()+ && solidcraft_engine::kernel::kernel_route::backend() == solidcraft_engine::kernel::kernel_route::Backend::Smlib+ {out["status"] = json!("unsupported");- out["error"] = json!("this build has no SMLib: build solidcraft-cli with --features smlib");+ out["error"] = json!("this build doesn't include the C++ SMLib kernel; build solidcraft-cli with --features smlib");return out;}// `refused`: only a clean refusal is right; `solid_or_refused`: a clean refusal, or a resultdiff --git a/apps/solidcraft-cli/tests/model_cache.rs b/apps/solidcraft-cli/tests/model_cache.rsindex ff94461d90..91011e67c6 100644--- a/apps/solidcraft-cli/tests/model_cache.rs+++ b/apps/solidcraft-cli/tests/model_cache.rs@@ -386,3 +386,44 @@ fn a_design_saved_before_names_were_pinned_opens_pinned_and_unchanged() {}let _ = std::fs::remove_file(&path);}++/// A saved model is its kernel's: the two differ in tolerances and in what they refuse, so a design+/// opened on the other kernel is evaluated on it, in both directions; on the kernel that saved it the+/// model is taken as it is. A process each, since the kernel is chosen for the process.+/// It reaches the C++ kernel on purpose: SOLIDCRAFT_KERNEL=smlib is the option under test.+#[cfg(feature = "smlib")]+#[test]+fn a_model_saved_on_one_kernel_is_evaluated_again_on_the_other() {+ let cli = || {+ let mut c = std::process::Command::new(env!("CARGO_BIN_EXE_solidcraft-cli"));+ c.env_remove("SOLIDCRAFT_NO_MODEL_CACHE");+ c+ };+ // Under the build's own temporary folder: the files are the command line's, not this process's.+ let temp = |name: &str| Path::new(env!("CARGO_TARGET_TMPDIR")).join(format!("model-cache-{}-{name}.solidcraft", std::process::id()));+ let script = temp("kernels-script").with_extension("json");+ let recipe = json!({"commands": [+ {"command": "solid.box", "params": {"length": 20, "width": 20, "height": 10, "body_name": "Plate"}},+ {"command": "solid.cylinder", "params": {"diameter": 8, "height": 10, "base": [10, 10, 10], "operation": "join", "targets": ["Plate"]}},+ ]});+ std::fs::write(&script, recipe.to_string()).unwrap();+ // Whether opening found a model in the file it may take, whether it took it, and how many+ // features it evaluated.+ let open = |design: &Path, kernel: &str| {+ let out = cli().env("SOLIDCRAFT_KERNEL", kernel).arg("bench-open").arg(design).output().unwrap();+ assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));+ let lines: Vec<Value> = String::from_utf8_lossy(&out.stdout).lines().filter_map(|l| serde_json::from_str(l).ok()).collect();+ let step = |name: &str| lines.iter().find(|l| l["step"] == name).cloned().unwrap();+ let (parse, evaluated) = (step("parse"), step("evaluate"));+ (parse["saved_model"].as_bool().unwrap(), evaluated["adopted"].as_bool().unwrap(), evaluated["recomputed"].as_u64().unwrap())+ };+ for (saved, other) in [("solidcore", "smlib"), ("smlib", "solidcore")] {+ let design = temp(&format!("kernels-{saved}"));+ let out = cli().env("SOLIDCRAFT_KERNEL", saved).arg("run").arg(&script).arg("--save").arg(&design).output().unwrap();+ assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));+ assert_eq!(open(&design, saved), (true, true, 0), "saved on {saved}, opened on it");+ assert_eq!(open(&design, other), (false, false, 2), "saved on {saved}, opened on {other}");+ std::fs::remove_file(&design).unwrap();+ }+ std::fs::remove_file(&script).unwrap();+}diff --git a/apps/solidcraft-web/Cargo.toml b/apps/solidcraft-web/Cargo.tomlindex 7a7661a88e..57b7c539f9 100644--- a/apps/solidcraft-web/Cargo.toml+++ b/apps/solidcraft-web/Cargo.toml@@ -14,11 +14,11 @@ name = "solidcraft-web"path = "src/main.rs"[features]-default = ["smlib", "profile"]+default = ["profile"]bundled-render-library = ["solidcraft-engine/bundled-render-library"]-# Link SMLib into the kernel (solidcraft-engine/smlib; needs scripts/fetch-smlib.sh-# wasm32-unknown-unknown, or the sources and wasi-sdk in WASI_SDK_PATH, crates/smlib/build.rs). SMLib-# is the only kernel, so without it the web app models nothing.+# Also link the C++ SMLib kernel (solidcraft-engine/smlib), off by default: needs+# scripts/fetch-smlib.sh wasm32-unknown-unknown, or the sources and wasi-sdk in WASI_SDK_PATH+# (crates/smlib/build.rs). solidcore, the Rust kernel, is always built and is the default either way.smlib = ["solidcraft-engine/smlib"]# The profiler, compiled in so any build can say where its time goes (the Profile operations# preference, SOLIDCRAFT_PROFILE=1, diagnostics.profile); it records nothing until asked.diff --git a/apps/solidcraft-web/build.rs b/apps/solidcraft-web/build.rsnew file mode 100644index 0000000000..a66d6cc007--- /dev/null+++ b/apps/solidcraft-web/build.rs@@ -0,0 +1,9 @@+//! Links the browser build with an 8 MiB stack: solidcore's kernel algorithms (subdivision,+//! intersection, filleting) recurse legitimately, and wasm has no guard page to catch an+//! overflow (solidcore's README recommends 8 MiB).++fn main() {+ if std::env::var("CARGO_CFG_TARGET_ARCH").is_ok_and(|a| a == "wasm32") {+ println!("cargo:rustc-link-arg=-zstack-size=8388608");+ }+}diff --git a/apps/solidcraft/Cargo.toml b/apps/solidcraft/Cargo.tomlindex 5e3bfc360b..6860706a12 100644--- a/apps/solidcraft/Cargo.toml+++ b/apps/solidcraft/Cargo.toml@@ -8,11 +8,12 @@ publish = falsedefault-run = "solidcraft"[features]-default = ["raytrace-cpu", "bundled-render-library", "smlib", "profile"]+default = ["raytrace-cpu", "bundled-render-library", "profile"]bundled-render-library = ["solidcraft-engine/bundled-render-library"]raytrace-cpu = ["solidcraft-engine/raytrace-cpu"]-# Link SMLib into the kernel (solidcraft-engine/smlib; needs scripts/fetch-smlib.sh). SMLib is the-# only kernel, so without it the app models nothing.+# Also link the C++ SMLib kernel (solidcraft-engine/smlib), off by default: needs a C++ toolchain+# and scripts/fetch-smlib.sh. solidcore, the Rust kernel, is always built and is the default either+# way; with this on, SOLIDCRAFT_KERNEL=smlib or the Geometry kernel preference can choose C++.smlib = ["solidcraft-engine/smlib"]# The profiler, compiled in so any build can say where its time goes (the Profile operations# preference, SOLIDCRAFT_PROFILE=1, diagnostics.profile); it records nothing until asked.diff --git a/assets/locales/pending/geometry-kernel.json b/assets/locales/pending/geometry-kernel.jsonnew file mode 100644index 0000000000..40cf1b438d--- /dev/null+++ b/assets/locales/pending/geometry-kernel.json@@ -0,0 +1,58 @@+{+ "en": {+ "cmd.diagnostics_kernel": "Geometry Kernel",+ "prefs.geometry_kernel": "Geometry kernel",+ "prefs.geometry_kernel_environment": "The SOLIDCRAFT_KERNEL environment variable is set; it wins over this setting.",+ "prefs.geometry_kernel_note": "solidcore, the default, answers every operation. Choose SMLib for the C++ kernel. A solidcore failure is reported, never retried on SMLib.",+ "prefs.geometry_kernel_unavailable": "SMLib is not available in this build. Operations run on solidcore."+ },+ "ar": {+ "cmd.diagnostics_kernel": "نواة الهندسة",+ "prefs.geometry_kernel": "نواة الهندسة",+ "prefs.geometry_kernel_environment": "متغير البيئة SOLIDCRAFT_KERNEL مضبوط، وله الأولوية على هذا الإعداد.",+ "prefs.geometry_kernel_note": "يجيب solidcore، وهو الافتراضي، عن كل العمليات. اختر SMLib لاستخدام نواة C++. ويُبلَّغ عن إخفاق solidcore ولا تُعاد المحاولة أبدًا على SMLib.",+ "prefs.geometry_kernel_unavailable": "SMLib غير متاح في هذا الإصدار. تعمل العمليات على solidcore."+ },+ "de": {+ "cmd.diagnostics_kernel": "Geometriekernel",+ "prefs.geometry_kernel": "Geometriekernel",+ "prefs.geometry_kernel_environment": "Die Umgebungsvariable SOLIDCRAFT_KERNEL ist gesetzt; sie hat Vorrang vor dieser Einstellung.",+ "prefs.geometry_kernel_note": "solidcore, die Standardeinstellung, führt alle Vorgänge aus. Wählen Sie SMLib für den C++-Kernel. Ein Fehler in solidcore wird gemeldet, nie mit SMLib wiederholt.",+ "prefs.geometry_kernel_unavailable": "SMLib ist in diesem Build nicht verfügbar. Vorgänge laufen auf solidcore."+ },+ "fr": {+ "cmd.diagnostics_kernel": "Noyau géométrique",+ "prefs.geometry_kernel": "Noyau géométrique",+ "prefs.geometry_kernel_environment": "La variable d’environnement SOLIDCRAFT_KERNEL est définie ; elle l’emporte sur ce réglage.",+ "prefs.geometry_kernel_note": "solidcore, le réglage par défaut, traite toutes les opérations. Choisissez SMLib pour le noyau C++. Un échec de solidcore est signalé, jamais réessayé avec SMLib.",+ "prefs.geometry_kernel_unavailable": "SMLib n’est pas disponible dans cette version. Les opérations s’exécutent sur solidcore."+ },+ "he": {+ "cmd.diagnostics_kernel": "ליבת גאומטריה",+ "prefs.geometry_kernel": "ליבת גאומטריה",+ "prefs.geometry_kernel_environment": "משתנה הסביבה SOLIDCRAFT_KERNEL מוגדר, והוא גובר על הגדרה זו.",+ "prefs.geometry_kernel_note": "solidcore, ברירת המחדל, מבצע את כל הפעולות. בחרו ב-SMLib עבור ליבת ה-C++. כשל של solidcore מדווח, ולעולם אינו מנוסה שוב ב-SMLib.",+ "prefs.geometry_kernel_unavailable": "SMLib אינו זמין בגרסה זו. הפעולות מתבצעות ב-solidcore."+ },+ "ja": {+ "cmd.diagnostics_kernel": "ジオメトリ カーネル",+ "prefs.geometry_kernel": "ジオメトリ カーネル",+ "prefs.geometry_kernel_environment": "環境変数 SOLIDCRAFT_KERNEL が設定されているため、この設定より優先されます。",+ "prefs.geometry_kernel_note": "既定の solidcore がすべての処理を行います。C++ カーネルを使うには SMLib を選択してください。solidcore の失敗は報告され、SMLib で再試行されることはありません。",+ "prefs.geometry_kernel_unavailable": "このビルドでは SMLib を利用できません。処理は solidcore で実行されます。"+ },+ "vi": {+ "cmd.diagnostics_kernel": "Nhân hình học",+ "prefs.geometry_kernel": "Nhân hình học",+ "prefs.geometry_kernel_environment": "Biến môi trường SOLIDCRAFT_KERNEL đã được đặt; biến này được ưu tiên hơn thiết lập này.",+ "prefs.geometry_kernel_note": "solidcore, mặc định, xử lý mọi thao tác. Chọn SMLib để dùng nhân C++. Lỗi của solidcore được báo cáo, không bao giờ thử lại trên SMLib.",+ "prefs.geometry_kernel_unavailable": "Bản dựng này không có SMLib. Các thao tác chạy trên solidcore."+ },+ "zh": {+ "cmd.diagnostics_kernel": "几何内核",+ "prefs.geometry_kernel": "几何内核",+ "prefs.geometry_kernel_environment": "已设置环境变量 SOLIDCRAFT_KERNEL,它优先于此设置。",+ "prefs.geometry_kernel_note": "默认的 solidcore 处理所有操作。如需使用 C++ 内核,请选择 SMLib。solidcore 失败时会报告,绝不会改用 SMLib 重试。",+ "prefs.geometry_kernel_unavailable": "此版本不提供 SMLib。操作在 solidcore 上运行。"+ }+}diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.tomlindex 6d813d931a..4a84293194 100644--- a/crates/engine/Cargo.toml+++ b/crates/engine/Cargo.toml@@ -13,7 +13,7 @@ default = []# Optional authored texture/HDR bytes; the command registry and metadata remain available.bundled-render-library = []raytrace-cpu = ["solidcraft-render/raytrace-cpu"]-# Link SMLib into the kernel (solidcraft-kernel/smlib; needs scripts/fetch-smlib.sh).+# Also link the C++ SMLib kernel (solidcraft-kernel/smlib, off by default; needs scripts/fetch-smlib.sh).smlib = ["solidcraft-kernel/smlib"]# Turns on the parameter-contract audit recorder (`SOLIDCRAFT_PARAM_AUDIT`, see# `src/schema/record.rs`), for checking a new contract against the whole test suite.diff --git a/crates/engine/src/cmd/diagnostics.rs b/crates/engine/src/cmd/diagnostics.rsindex 5c62a1df4d..70fee4e01a 100644--- a/crates/engine/src/cmd/diagnostics.rs+++ b/crates/engine/src/cmd/diagnostics.rs@@ -55,11 +55,22 @@ pub static COMMANDS: &[CommandSpec] = &[trace?: path (write the recorded spans as a Chrome trace-event file, for chrome://tracing or Perfetto). Returns what \was recorded before enabled and reset apply: {compiled, enabled, wall_ms, spans, dropped, by_category: [{category, \self_ms, share}], rows: [{category, name, count, total_ms, self_ms, max_ms}], rows_total, trace?}, the rows the most \- self time first. Categories: smlib (SMLib's C API calls, timed by the C API), kernel, feature (one per feature \+ self time first. Categories: solidcore (the kernel's calls), smlib (SMLib's C API calls, timed by the C API, when it is asked for), kernel, feature (one per feature \computed, by its type), doc, command, import (STEP/IGES stages), io. Self time is a span's time less the spans \inside it; total counts its outermost run only. Recording also starts with SOLIDCRAFT_PROFILE=1, the CLI's \--profile and the app's preference; off, it costs nothing measurable. Read-only",),+ CommandSpec::new("diagnostics.kernel", "Geometry Kernel", crate::checked!("diagnostics.kernel", kernel))+ .icon("bug_report")+ .noundo()+ .contract(&KERNEL_CONTRACT)+ .output(output_schema_for::<crate::schema::diagnostics::KernelReply>)+ .params(+ "choice?: solidcore | smlib (sets which kernel answers every operation: solidcore, the default = the Rust port; \+ smlib = the C++ SMLib kernel, refused as not available on a build without it, such as the web app; bodies already \+ computed keep their results). SOLIDCRAFT_KERNEL, when set, wins over it. Returns {choice, environment}: choice is \+ the kernel in force, environment whether SOLIDCRAFT_KERNEL chose it",+ ),CommandSpec::new("diagnostics.validation", "Validation", crate::checked!("diagnostics.validation", validation)).icon("bug_report").noundo()@@ -85,6 +96,34 @@ pub static COMMANDS: &[CommandSpec] = &[),];+fn kernel(_: &mut Session, p: &Value) -> Result<Value> {+ use solidcraft_kernel::kernel_route as route;+ if let Some(v) = p.get("choice").filter(|v| !v.is_null()) {+ route::set_choice(kernel_asked(v, solidcraft_kernel::smlib_built())?);+ }+ use crate::schema::diagnostics::{KernelChoice, KernelReply};+ let choice = match route::choice() {+ route::Backend::Solidcore => KernelChoice::Solidcore,+ route::Backend::Smlib => KernelChoice::Smlib,+ };+ serde_json::to_value(KernelReply { choice, environment: route::overridden() }).map_err(|e| bad("diagnostics.kernel", e.to_string()))+}++/// The kernel `choice` asks for, on a build that has (`built`) the C++ kernel or doesn't. A choice of+/// the wrong type is refused like an unknown one, not read as no choice; `smlib` on a build without+/// it is refused too, never answered by the other kernel.+pub(crate) fn kernel_asked(choice: &Value, built: bool) -> Result<solidcraft_kernel::kernel_route::Backend> {+ use solidcraft_kernel::kernel_route::Backend;+ let asked = choice.as_str().and_then(Backend::from_id).ok_or_else(|| bad("diagnostics.kernel", "`choice` is solidcore or smlib"))?;+ if asked == Backend::Smlib && !built {+ return Err(EngineError::Disabled(+ "diagnostics.kernel".into(),+ "this build doesn't include the C++ SMLib kernel; build with --features smlib".into(),+ ));+ }+ Ok(asked)+}+fn dir(cmd: &str) -> Result<std::path::PathBuf> {crash::default_dir().ok_or_else(|| bad(cmd, "no crash folder on this system"))}@@ -143,6 +182,7 @@ fn crash_test(_: &mut Session, p: &Value) -> Result<Value> {const PROFILE_CONTRACT: crate::schema::TypedContract<crate::schema::diagnostics::ProfileParams> = crate::schema::TypedContract::new();+const KERNEL_CONTRACT: crate::schema::TypedContract<crate::schema::diagnostics::KernelParams> = crate::schema::TypedContract::new();const VALIDATION_CONTRACT: crate::schema::TypedContract<crate::schema::diagnostics::ValidationParams> = crate::schema::TypedContract::new();fn validation(s: &mut Session, p: &Value) -> Result<Value> {diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rsindex 2f36c7b617..79552bf01c 100644--- a/crates/engine/src/cmd/file.rs+++ b/crates/engine/src/cmd/file.rs@@ -1124,8 +1124,7 @@ mod tests {use super::*;/// While the profiler records, a STEP import's reply carries its own profile: the import's- /// stages and SMLib's calls, as diagnostics.profile reports them.- #[cfg(feature = "smlib")]+ /// stages and the kernel's calls, as diagnostics.profile reports them.#[test]fn a_step_import_reports_its_profile_while_the_profiler_records() {let _serial = crate::schema::diagnostics::PROFILE_TESTS.lock().unwrap_or_else(std::sync::PoisonError::into_inner);@@ -1144,7 +1143,7 @@ mod tests {let p = &out["profile"];let rows = p["rows"].as_array().unwrap();let has = |cat: &str| rows.iter().any(|r| r["category"] == cat);- assert!(has("import") && has("smlib"), "{p}");+ assert!(has("import") && (has("solidcore") || has("smlib")), "{p}");assert!(p["by_category"].as_array().is_some_and(|c| !c.is_empty()) && p["wall_ms"].as_f64().is_some_and(|w| w > 0.0), "{p}");}diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rsindex e9b4a84eb9..9cff4d96de 100644--- a/crates/engine/src/cmd/mod.rs+++ b/crates/engine/src/cmd/mod.rs@@ -34,7 +34,7 @@ mod component_clone;mod component_clone_assembly;mod construct;mod delete;-mod diagnostics;+pub(crate) mod diagnostics;mod edit;mod face;mod features;diff --git a/crates/engine/src/schema/diagnostics.rs b/crates/engine/src/schema/diagnostics.rsindex 306fe1b1b6..30245bda9d 100644--- a/crates/engine/src/schema/diagnostics.rs+++ b/crates/engine/src/schema/diagnostics.rs@@ -330,6 +330,44 @@ impl From<solidcraft_kernel::Validation> for ValidationMode {}}+/// Read, or set, which kernel answers every operation.+#[derive(Debug, Default, Deserialize, JsonSchema)]+#[schemars(deny_unknown_fields)]+pub struct KernelParams {+ /// The kernel to use from now on. Default: leave it as it is. `smlib` is refused on a build+ /// without the C++ kernel; `SOLIDCRAFT_KERNEL`, when set, wins over it.+ #[serde(default, deserialize_with = "kernel_choice")]+ pub choice: Option<KernelChoice>,+}++/// A geometry kernel.+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]+#[serde(rename_all = "snake_case")]+pub enum KernelChoice {+ /// solidcore, the Rust port of SMLib (the default).+ Solidcore,+ /// The C++ SMLib kernel.+ Smlib,+}++fn kernel_choice<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Option<KernelChoice>, D::Error> {+ match Value::deserialize(d)? {+ Value::Null => Ok(None),+ Value::String(s) if s == "solidcore" => Ok(Some(KernelChoice::Solidcore)),+ Value::String(s) if s == "smlib" => Ok(Some(KernelChoice::Smlib)),+ _ => Err(serde::de::Error::custom(super::check::whole("`choice` is solidcore or smlib"))),+ }+}++/// The reply of `diagnostics.kernel`.+#[derive(Debug, Serialize, JsonSchema)]+pub struct KernelReply {+ /// The kernel in force now.+ pub choice: KernelChoice,+ /// Whether `SOLIDCRAFT_KERNEL` chose it.+ pub environment: bool,+}+/// Read, or set, when SMLib's full check runs on the features computed from now on.#[derive(Debug, Default, Deserialize, JsonSchema)]#[schemars(deny_unknown_fields)]diff --git a/crates/engine/src/schema/diagnostics_tests.rs b/crates/engine/src/schema/diagnostics_tests.rsindex a16432ab71..920c07697f 100644--- a/crates/engine/src/schema/diagnostics_tests.rs+++ b/crates/engine/src/schema/diagnostics_tests.rs@@ -2,7 +2,7 @@ use serde_json::{Value, json};use super::{CrashReport, CrashReportList, CrashReportParams, CrashReportsClearParams, CrashReportsCleared, CrashReportsParams, CrashTestMode,- CrashTestParams, ProfileParams, ValidationParams,+ CrashTestParams, KernelParams, ProfileParams, ValidationParams,};use crate::Session;use crate::schema::tests::{assert_keys, assert_strict_keeps_todays_errors, conforms};@@ -16,6 +16,7 @@ fn schemas_and_the_key_check_agree() {assert_keys(input_schema_for::<CrashTestParams>(), &["mode"]);assert_keys(input_schema_for::<ProfileParams>(), &["enabled", "reset", "top", "trace"]);assert_keys(input_schema_for::<ValidationParams>(), &["mode"]);+ assert_keys(input_schema_for::<KernelParams>(), &["choice"]);}#[test]@@ -29,6 +30,8 @@ fn strict_keeps_todays_errors() {("diagnostics.profile", json!({"trace": 5})),("diagnostics.validation", json!({"mode": "each step"})),("diagnostics.validation", json!({"mode": true})),+ ("diagnostics.kernel", json!({"choice": "cpp"})),+ ("diagnostics.kernel", json!({"choice": 1})),]);}@@ -151,6 +154,94 @@ fn diagnostics_profile_reports_commands_features_and_the_kernel() {let _ = std::fs::remove_dir_all(&dir);}+/// Tests that set the process-wide kernel choice run one at a time, and put `solidcore` back+/// however they end (a failed assertion included).+struct KernelChoice(#[allow(dead_code)] std::sync::MutexGuard<'static, ()>);++static KERNEL_TESTS: std::sync::Mutex<()> = std::sync::Mutex::new(());++impl KernelChoice {+ fn take() -> Self {+ KernelChoice(KERNEL_TESTS.lock().unwrap_or_else(std::sync::PoisonError::into_inner))+ }+}++impl Drop for KernelChoice {+ fn drop(&mut self) {+ solidcraft_kernel::kernel_route::set_choice(solidcraft_kernel::kernel_route::Backend::Solidcore);+ }+}++/// diagnostics.kernel says the kernel in force and whether the environment chose it, and its+/// `choice` sets it (unless SOLIDCRAFT_KERNEL overrides it).+///+/// The choice is process-wide and the other tests in this binary build bodies meanwhile, so only+/// `solidcore` is set through the command; what `smlib` asks for is read from `kernel_asked`.+#[test]+fn diagnostics_kernel_reports_and_sets_the_choice() {+ use solidcraft_kernel::kernel_route as route;+ let _choice = KernelChoice::take();+ let mut s = Session::default();+ let r = s.execute("diagnostics.kernel", &json!({})).unwrap();+ let environment = route::overridden();+ assert_eq!(r, json!({ "choice": route::choice().id(), "environment": environment }));+ let r = s.execute("diagnostics.kernel", &json!({ "choice": "solidcore" })).unwrap();+ assert!(environment || r["choice"] == json!("solidcore"), "{r}");+ assert_eq!(crate::cmd::diagnostics::kernel_asked(&json!("solidcore"), false).unwrap(), route::Backend::Solidcore);+ assert_eq!(crate::cmd::diagnostics::kernel_asked(&json!("solidcore"), true).unwrap(), route::Backend::Solidcore);+ assert_eq!(crate::cmd::diagnostics::kernel_asked(&json!("smlib"), true).unwrap(), route::Backend::Smlib);+}++/// `smlib` on a build without the C++ kernel is refused as not available, whichever kernel is in+/// force, and leaves the choice alone: never an answer from the other kernel. Built with it, the+/// command would move the other tests' bodies, so `kernel_asked` alone is asked.+#[test]+fn diagnostics_kernel_refuses_smlib_on_a_build_without_it() {+ let _choice = KernelChoice::take();+ let refused = crate::cmd::diagnostics::kernel_asked(&json!("smlib"), false).unwrap_err();+ assert!(matches!(&refused, crate::EngineError::Disabled(cmd, _) if cmd == "diagnostics.kernel"), "{refused}");+ if !solidcraft_kernel::smlib_built() {+ let mut s = Session::default();+ let before = s.execute("diagnostics.kernel", &json!({})).unwrap();+ assert!(matches!(s.execute("diagnostics.kernel", &json!({"choice": "smlib"})), Err(crate::EngineError::Disabled(..))));+ assert_eq!(s.execute("diagnostics.kernel", &json!({})).unwrap(), before);+ }+}++/// An unknown or mistyped choice is an error that changes nothing; no hostile value panics.+#[test]+fn diagnostics_kernel_refuses_unknown_choices() {+ let _choice = KernelChoice::take();+ let mut s = Session::default();+ let before = s.execute("diagnostics.kernel", &json!({})).unwrap()["choice"].clone();+ let huge = "solidcore".repeat(100_000);+ for bad in [+ json!("truck"),+ json!("SMLIB"),+ json!(""),+ json!(huge),+ json!("routed"),+ json!("routed\0"),+ json!(5),+ json!(true),+ json!(["smlib"]),+ json!({"choice": "smlib"}),+ ] {+ match s.execute("diagnostics.kernel", &json!({ "choice": bad })) {+ Err(crate::EngineError::BadParams { .. }) => {}+ other => panic!("`{}` was not refused: {:?}", bad.as_str().map_or(0, str::len), other.map_err(|e| e.to_string())),+ }+ }+ for v in crate::tests::hostile_values() {+ for p in [json!({ "choice": v.clone() }), v] {+ if let Err(crate::EngineError::Internal(_, msg)) = s.execute("diagnostics.kernel", &p) {+ panic!("diagnostics.kernel {p}: {msg}");+ }+ }+ }+ assert_eq!(s.execute("diagnostics.kernel", &json!({})).unwrap()["choice"], before);+}+/// Features are checked once each by default; the command reads and sets the mode, and the mode/// is the user's: it stays when another design is started and when everything is computed again.#[test]diff --git a/crates/geom/src/tess/uv.rs b/crates/geom/src/tess/uv.rsindex bd45eba6d2..fe944c43e8 100644--- a/crates/geom/src/tess/uv.rs+++ b/crates/geom/src/tess/uv.rs@@ -109,12 +109,25 @@ fn clamped(p: usize, n: usize, k: &[f64]) -> bool {p >= 1 && k.len() == n + p + 1 && ends(1..=p) && ends(n..=n + p - 1)}-/// `x` moved by whole periods `b − a` into `[a, b]` when it lies outside.+/// How far past an end of the interval, relative to its size, a parameter is still that end:+/// rounding, not a period away.+const WRAP_SLACK: f64 = 1e-12;++/// `x` moved by whole periods `b − a` into `[a, b]` when it lies outside. A parameter a rounding+/// past an end (a pcurve ending on the seam one ulp beyond it) is that end, not moved a period+/// to the other one: a plan's node there would put its triangles across the whole period.pub(crate) fn wrap_into(x: f64, (a, b): (f64, f64)) -> f64 {let period = b - a;if (a..=b).contains(&x) || !(period > 0.0) {return x;}+ let slack = WRAP_SLACK * period.max(a.abs()).max(b.abs());+ if x > b && x - b <= slack {+ return b;+ }+ if x < a && a - x <= slack {+ return a;+ }let w = x - ((x - a) / period).floor() * period;w.clamp(a, b)}@@ -410,6 +423,9 @@ mod tests {}assert_eq!(s.wrap([1.0, 0.5]), [1.0, 0.5]);assert_eq!(s.wrap([1.25, 2.0]), [0.25, 2.0]);+ // A rounding past an end is that end, not the other one a period away.+ assert_eq!(s.wrap([1.0 + f64::EPSILON, 0.5]), [1.0, 0.5]);+ assert_eq!(s.wrap([-1e-17, 0.5]), [0.0, 0.5]);// Projection finds a point near the seam from either side.let p = s.derivs(0.02, 0.5).map(|d| d.0).unwrap_or(Vec3::ZERO);let dom = domain(&s);diff --git a/crates/gpu/Cargo.toml b/crates/gpu/Cargo.tomlindex 975d01f923..2ba7d096a0 100644--- a/crates/gpu/Cargo.toml+++ b/crates/gpu/Cargo.toml@@ -26,9 +26,9 @@ wgpu = { workspace = true, features = ["metal", "vulkan", "dx12", "gles"] }[dev-dependencies]image = { workspace = true }solidcraft-kernel = { workspace = true }-# Headless pictures of real designs (capture tests), built by the real kernel: SMLib-# (scripts/fetch-smlib.sh), as in the apps.-solidcraft-engine = { workspace = true, features = ["bundled-render-library", "smlib"] }+# Headless pictures of real designs (capture tests), built by the real kernel: solidcore, as in the+# apps (the C++ SMLib kernel only when the build turns on solidcraft-engine/smlib).+solidcraft-engine = { workspace = true, features = ["bundled-render-library"] }solidcraft-io = { workspace = true }serde_json = { workspace = true }# The HLSL the D3D12 backend compiles (tests check it suits FXC).diff --git a/crates/io/src/design.rs b/crates/io/src/design.rsindex f097b28aef..5481075433 100644--- a/crates/io/src/design.rs+++ b/crates/io/src/design.rs@@ -1215,7 +1215,7 @@ mod tests {let tree: Value = serde_json::from_slice(manifest).unwrap();assert_eq!(serde_json::to_vec(&tree).unwrap(), *manifest);assert_eq!(tree["model"], model.records);- assert_eq!(tree.as_object().unwrap().len(), 11, "{:?}", tree.as_object().unwrap().keys().collect::<Vec<_>>());+ assert_eq!(tree.as_object().unwrap().len(), 12, "{:?}", tree.as_object().unwrap().keys().collect::<Vec<_>>());}/// #9170: a mesh body (an imported STL) is kept in the model cache with the rest of the@@ -1474,7 +1474,7 @@ mod tests {let doc = document();let bytes = write_design_container_with_cache(&doc, DesignCompression::Fast, None, Some(&native_geometry())).unwrap();let original = parts(&bytes);- for key in ["format", "producer", "evaluation", "document", "payload"] {+ for key in ["format", "producer", "evaluation", "kernel", "document", "payload"] {let mut entries = original.clone();let mut manifest: Value = serde_json::from_slice(&entries["cache/model.json"]).unwrap();manifest[key] = json!("unsupported-or-stale");@@ -1548,6 +1548,19 @@ mod tests {manifest.as_object_mut().unwrap().remove("evaluation");entries.insert("cache/model.json".into(), serde_json::to_vec(&manifest).unwrap());assert!(read_design_geometry(&package(&entries)).is_none());+ // The kernel that computed it is recorded, and another kernel's model is evaluated again:+ // the same source gives different bodies on the two (a cache without one is a miss too).+ use solidcraft_kernel::kernel_route::{Backend, choice};+ assert_eq!(written(&original)["kernel"], json!(choice().id()));+ let other = if choice() == Backend::Solidcore { Backend::Smlib } else { Backend::Solidcore };+ let bytes = with(&[("kernel", other.id())]);+ assert!(read_design_geometry(&bytes).is_none(), "{}'s cache", other.id());+ assert_eq!(crate::read_design(&bytes).unwrap().to_json(), doc.to_json());+ let mut entries = original.clone();+ let mut manifest = written(&entries);+ manifest.as_object_mut().unwrap().remove("kernel");+ entries.insert("cache/model.json".into(), serde_json::to_vec(&manifest).unwrap());+ assert!(read_design_geometry(&package(&entries)).is_none());}#[test]diff --git a/crates/io/src/design/native_cache.rs b/crates/io/src/design/native_cache.rsindex d50df84d04..90cc117078 100644--- a/crates/io/src/design/native_cache.rs+++ b/crates/io/src/design/native_cache.rs@@ -1,7 +1,7 @@//! The model cache: a design's evaluated timeline (every feature's result and the state after//! it, [`SavedModel`]), saved with it so opening need not evaluate it again. Bodies use//! SolidCraft's exact native B-rep encoding (a mesh body, its own triangles); the key ties the-//! cache to the exact document, and to the source and platform that computed it+//! cache to the exact document, and to the source, platform and geometry kernel that computed it//! (docs/design-container.md).use super::*;use solidcraft_doc::{ModelState, SavedModel};@@ -29,6 +29,12 @@ fn evaluation() -> String {format!("{}/{}-{}", env!("SOLIDCRAFT_EVALUATION_SOURCE"), std::env::consts::ARCH, std::env::consts::OS)}+/// The geometry kernel that answers in this process: another kernel's cache is not its result (the+/// two differ in tolerances and in what they refuse), so a design opened under it evaluates again.+fn kernel() -> &'static str {+ solidcraft_kernel::kernel_route::choice().id()+}+/// A 4 x 4 matrix as its 16 numbers, in storage order.fn matrix(t: &[[f64; 4]; 4]) -> Vec<f64> {t.iter().flatten().copied().collect()@@ -296,6 +302,7 @@ impl Encoded {document: digest(document),evaluation: evaluation(),format: FORMAT,+ kernel: kernel(),model: records,payload: digest(&data),producer: PRODUCER,@@ -320,6 +327,7 @@ struct Manifest<'a> {document: String,evaluation: String,format: &'a str,+ kernel: &'a str,model: &'a Value,payload: String,producer: &'a str,@@ -336,14 +344,15 @@ pub fn read_design_geometry(bytes: &[u8]) -> Option<std::sync::Arc<ModelState>>DesignContainerReader::new(Cursor::new(bytes)).ok()?.geometry()?.final_state().ok()}-/// Whether `manifest` is a model cache of this build's evaluation source for `document`. The-/// application version and commit that wrote it are not asked: another version of the same+/// Whether `manifest` is a model cache of this build's evaluation source and kernel for `document`.+/// The application version and commit that wrote it are not asked: another version of the same/// evaluation source computed the same model.fn current(manifest: &Value, document: &[u8]) -> bool {let is = |key: &str, value: &str| manifest.get(key).and_then(Value::as_str) == Some(value);is("format", FORMAT)&& is("producer", PRODUCER)&& is("evaluation", &evaluation())+ && is("kernel", kernel())&& is("document", &digest(document))&& source_trusted(env!("SOLIDCRAFT_EVALUATION_SOURCE"), cfg!(any(test, feature = "trust-unknown-source")))}diff --git a/crates/kernel/Cargo.toml b/crates/kernel/Cargo.tomlindex 7d922123c6..29afa888f7 100644--- a/crates/kernel/Cargo.toml+++ b/crates/kernel/Cargo.toml@@ -9,9 +9,9 @@ license.workspace = trueworkspace = true[features]-# Link NVIDIA's SMLib (tangency-labs/smlib) into the kernel; needs a C++ toolchain and-# scripts/fetch-smlib.sh (ADR 0002). Without it every geometric operation answers that SMLib-# was not built.+# Also link NVIDIA's C++ SMLib (tangency-labs/smlib), off by default; needs a C++ toolchain and+# scripts/fetch-smlib.sh (ADR 0002). solidcore, the Rust port, answers every operation either way;+# without this, asking for the C++ kernel (SOLIDCRAFT_KERNEL=smlib) is refused as not built.smlib = ["solidcraft-smlib/native"][dependencies]diff --git a/crates/kernel/src/blend_smlib.rs b/crates/kernel/src/blend_smlib.rsindex 2512d5395c..46615328cc 100644--- a/crates/kernel/src/blend_smlib.rs+++ b/crates/kernel/src/blend_smlib.rs@@ -453,6 +453,7 @@ mod imp {)),_ => KernelError::TooLarge(format!("the {what} is larger than the faces beside its edges allow")),},+ SmError::Unported(why) => KernelError::Invalid(format!("not supported yet: {why}")),e => failed(what, "operation", e),})?;// Checked here unless the evaluation's validation mode leaves it to the feature's enddiff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rsindex a08edcc2cb..993e0af631 100644--- a/crates/kernel/src/lib.rs+++ b/crates/kernel/src/lib.rs@@ -214,6 +214,8 @@ pub use prism_curve::{PlanarPiece, PlanarSpline};pub use prism_measure::{PrismSection, certified_prism_equivalent, certified_prism_section};pub use repair::{Hole, RebuiltFace, RefusedFace, RepairOptions, RepairReport, SewnGap, repair};pub use sew::{EdgeSpec, FaceSpec, SurfSpec, sew, sew_touching};+/// Which kernel the process runs on, solidcore or SMLib (crates/smlib/src/route.rs).+pub use solidcraft_smlib::route as kernel_route;pub use splitface::{SplitTool, split_body, split_faces, split_faces_with_map};pub use step::step_export;pub use step_in::{diff --git a/crates/kernel/src/prism.rs b/crates/kernel/src/prism.rsindex 542e601bec..6868a069c2 100644--- a/crates/kernel/src/prism.rs+++ b/crates/kernel/src/prism.rs@@ -108,7 +108,6 @@ struct Regions {touching: bool,}-#[cfg(feature = "smlib")]mod sheets {use solidcraft_geom::Loop2;use solidcraft_geom::Vec3;@@ -289,30 +288,6 @@ mod sheets {}}-#[cfg(not(feature = "smlib"))]-mod sheets {- use super::*;-- fn refused<T>() -> Result<T> {- Err(KernelError::Failed("not supported yet: planar region booleans run on SMLib (build with the feature `smlib`)".into()))- }-- /// A sheet stands for nothing without SMLib.- pub(super) enum Sheet {}-- pub(super) fn sheet(_: &[Region2], _: f64) -> Result<Sheet> {- refused()- }-- pub(super) fn combine(a: &Sheet, _: &Sheet, _: BoolOp) -> Result<Option<Sheet>> {- match *a {}- }-- pub(super) fn regions(sheet: &Sheet, _: f64) -> Result<Regions> {- match *sheet {}- }-}-#[cfg(test)]#[allow(clippy::unwrap_used, clippy::panic)]mod planar_tests {diff --git a/crates/kernel/src/prism_curve.rs b/crates/kernel/src/prism_curve.rsindex 121112ae10..4b4e47aa0a 100644--- a/crates/kernel/src/prism_curve.rs+++ b/crates/kernel/src/prism_curve.rs@@ -302,8 +302,7 @@ pub(crate) fn segment(run: &Run, plane: &Plane, tol: f64, work: &mut usize) -> O/// `run` in `plane` exactly as segments: as [`segment`], and a curve of several Bézier spans/// (a chain of a font's curves, a spline through points) as one segment per span, each the/// line, conic or Bézier it is, for a planar region's outline. `None` when the edge doesn't lie-/// in a plane parallel to `plane` or isn't read exactly. Only planar sheets read on SMLib use it.-#[cfg(feature = "smlib")]+/// in a plane parallel to `plane` or isn't read exactly.pub(crate) fn projected(run: &Run, plane: &Plane, tol: f64, work: &mut usize) -> Option<Vec<Seg2>> {read(run, plane, tol, work, true)}diff --git a/crates/kernel/src/profile.rs b/crates/kernel/src/profile.rsindex deb156c716..f0bd876c9e 100644--- a/crates/kernel/src/profile.rs+++ b/crates/kernel/src/profile.rs@@ -192,9 +192,10 @@ mod tests {let k = row("kernel", "boolean").unwrap_or_else(|| panic!("{rep:?}"));assert!(k.count >= 1 && row("kernel", "box_solid").is_some(), "{rep:?}");if r.is_ok() {- // With SMLib built, its calls are children of the boolean: their time is not its self time.- let smlib: std::time::Duration = rep.rows.iter().filter(|r| r.category == "smlib").map(|r| r.total).sum();- assert!(smlib > std::time::Duration::ZERO && k.self_time < k.total, "{rep:?}");+ // The geometry kernel's calls, on whichever answers, are children of the boolean: their+ // time is not its self time.+ let calls: std::time::Duration = rep.rows.iter().filter(|r| matches!(r.category, "smlib" | "solidcore")).map(|r| r.total).sum();+ assert!(calls > std::time::Duration::ZERO && k.self_time < k.total, "{rep:?}");}}}diff --git a/crates/kernel/src/step_in/tests.rs b/crates/kernel/src/step_in/tests.rsindex 043c639688..a86bac8d31 100644--- a/crates/kernel/src/step_in/tests.rs+++ b/crates/kernel/src/step_in/tests.rs@@ -540,12 +540,18 @@ fn offset_surface_cube_import_is_closed_and_editable() {assert!(rel(measure(&result).unwrap().volume, 1000.0 - 40.0 * std::f64::consts::PI) < 1e-3);}-/// A solid whose B-rep SMLib refuses, its faces too (here every SMLib call: the build has no-/// SMLib), is refused with the kernel's reason, naming the solid. It once came in as a mesh of-/// its faces, which the planner could still triangulate.+/// A solid whose B-rep SMLib refuses, its faces too (here every SMLib call: the C++ kernel is asked+/// for, SOLIDCRAFT_KERNEL=smlib, on a build without it), is refused with the kernel's reason, naming+/// the solid. It once came in as a mesh of its faces, which the planner could still triangulate.+/// On solidcore, the default, the cube imports, so there is nothing to refuse.#[cfg(not(feature = "smlib"))]#[test]fn a_solid_smlib_refuses_with_its_faces_is_refused_not_meshed() {+ use crate::kernel_route::{Backend, choice};+ if choice() != Backend::Smlib {+ eprintln!("skipped: needs SOLIDCRAFT_KERNEL=smlib on a build without the C++ kernel");+ return;+ }let text = format!("{HEAD}{}#60=SHAPE_REPRESENTATION('',(#101),$);\n{TAIL}", cube_entities());let why = step_import(&text).map(|imp| imp.warnings).unwrap_err().to_string();assert!(why.contains("solid 'Cube': not imported: ") && why.contains("SMLib"), "{why}");diff --git a/crates/kernel/src/taper_mesh_tests.rs b/crates/kernel/src/taper_mesh_tests.rsindex 14ba6fa847..12287b7c86 100644--- a/crates/kernel/src/taper_mesh_tests.rs+++ b/crates/kernel/src/taper_mesh_tests.rs@@ -1,9 +1,14 @@use super::*;-fn wedge() -> Body {+/// A wedge 40 x 20, 15 high, its top front edge along x from 0 to 40.+fn wedge_body() -> Body {use solidcraft_geom::{Loop2, Plane, Region2, Vec2};let outer = Loop2::polygon(&[Vec2::new(0., 0.), Vec2::new(40., 0.), Vec2::new(0., 20.)]);- let body = crate::extrude(&Plane::XY, &[Region2 { outer, holes: vec![] }], 0., 15.).unwrap().pop().unwrap();+ crate::extrude(&Plane::XY, &[Region2 { outer, holes: vec![] }], 0., 15.).unwrap().pop().unwrap()+}++fn wedge() -> Body {+ let body = wedge_body();let at = Vec3::new(20., 0., 15.);// The room's taper, closing to zero at the wedge's tip, given as a spline fillet: R16 itself// is built over the wedge's cliffs (the blend-overflow decision), so a tapered fillet no@@ -12,6 +17,16 @@ fn wedge() -> Body {fillet_variable_spline(&body, at, t.start, &t.spline).unwrap()}+/// The wedge's variable round takes off the union of its balls (smlib#78, solidcore#2262):+/// `removed_by_balls` along the 40 mm edge, about 754.28, on whichever kernel the test runs.+#[test]+fn the_wedge_round_keeps_its_volume() {+ let v = crate::measure(&wedge()).unwrap().volume;+ let law = taper(&wedge_body(), Vec3::new(20., 0., 15.), 16.).unwrap().spline;+ let want = 6000.0 - super::tests::removed_by_balls(40.0, &|u| law.eval(u), &|_, _| f64::INFINITY, &[]);+ assert!(((v - want) / want).abs() < 1e-4, "{v} vs {want}");+}+/// The display mesh of a fillet tapering to zero at a wedge's tip converges to the B-rep: each/// mesh lies within its chord tolerance of the faces, so its volume is within the body's area/// times that tolerance of the exact one (SMLib's, integrated on the surfaces, to 1e-8). Onlydiff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rsindex 261cf029c1..b3fdff69a4 100644--- a/crates/kernel/src/tests.rs+++ b/crates/kernel/src/tests.rs@@ -1724,17 +1724,14 @@ fn tabbed_plate_area(da: f64, dt: f64) -> f64 {0.5 * (big * big * (PI + 2.0 * at) + tab) + (4.0 - dt) * (cy - yc)}-#[test]-fn fillet_tabbed_plate_outer_loop_and_partial_selection_after_hole() {+/// The tabbed plate's outer outline, reconstructed from its seven public pick coordinates: an R25+/// plate, x = ±4 tab sides, R2 corners centred at (±2, 280/9) and a 4 mm straight top.+fn tabbed_plate_outline() -> Loop2 {use solidcraft_geom::Seg2;- // Reconstruct the outer outline from its seven public pick coordinates:- // R25 plate, x=+/-4 tab sides, R2 corners and a 4 mm straight top.- // The hole's dimensions come from the public reproduction, not an original design file.let theta = (4.0_f64 / 25.0).acos();let y = (625.0_f64 - 16.0).sqrt();let corner_y = 280.0 / 9.0;- let hole_y = 262.0 / 9.0;- let outline = Loop2 {+ Loop2 {segs: vec![Seg2::Arc { center: Vec2::ZERO, radius: 25.0, start: PI - theta, sweep: PI + 2.0 * theta },Seg2::Line { a: Vec2::new(4.0, y), b: Vec2::new(4.0, corner_y) },@@ -1743,7 +1740,43 @@ fn fillet_tabbed_plate_outer_loop_and_partial_selection_after_hole() {Seg2::Arc { center: Vec2::new(-2.0, corner_y), radius: 2.0, start: PI / 2.0, sweep: PI / 2.0 },Seg2::Line { a: Vec2::new(-4.0, corner_y), b: Vec2::new(-4.0, y) },],- };+ }+}++/// solidcore#2223: the tabbed plate's R25 rim and one R2 tab corner arc, which share no vertex,+/// rounded together at r 0.5 on the plate 2 high (no hole). Each rounds alone; together they+/// failed 1001 in cliff_overflow. They take off the sum: the rim alone's 7.958674274526857+/// (solidcore#2176's pinned value) and the corner arc's Pappus volume with flat ends,+/// 0.15913583972191622 (the spandrel (1 − π/4) r² about the corner's axis at 2 − its centroid+/// over a quarter turn), 8.117810114.+#[test]+fn fillet_tabbed_plate_rim_and_one_corner_arc_together() {+ let body = extrude(&Plane::XY, &[Region2 { outer: tabbed_plate_outline(), holes: vec![] }], 0.0, 2.0).unwrap().pop().unwrap();+ let r = 0.5;+ let (spandrel, centroid) = ((1.0 - PI / 4.0) * r * r, r * (10.0 - 3.0 * PI) / (3.0 * (4.0 - PI)));+ let corner = spandrel * (PI / 2.0) * (2.0 - centroid);+ assert!((corner - 0.159_135_839_721_916_22).abs() < 1e-12, "{corner}");+ let want = 7.958_674_274_526_857 + corner;+ let picks = [+ Vec3::new(-24.91935125502191, -2.0064727829797544, 2.0),+ Vec3::new(24.919351255429795, -2.006472777913911, 2.0),+ Vec3::new(3.4142135598750105, 32.525324672801695, 2.0),+ ];+ let blended = fillet(&body, &picks, r).unwrap_or_else(|e| panic!("rim and corner arc together: {e}"));+ assert!(blended.validity().is_empty(), "{:?}", blended.validity());+ assert_eq!(blended.face_count(), 12);+ let got = measure(&body).unwrap().volume - measure(&blended).unwrap().volume;+ assert!((got - want).abs() < 1e-7, "removed {got}, expected {want}");+}++#[test]+fn fillet_tabbed_plate_outer_loop_and_partial_selection_after_hole() {+ // The hole's dimensions come from the public reproduction, not an original design file.+ let theta = (4.0_f64 / 25.0).acos();+ let y = (625.0_f64 - 16.0).sqrt();+ let corner_y = 280.0 / 9.0;+ let hole_y = 262.0 / 9.0;+ let outline = tabbed_plate_outline();let body =extrude(&Plane::XY, &[Region2 { outer: outline, holes: vec![Loop2::circle(Vec2::new(0.0, hole_y), 1.5)] }], 0.0, 2.0).unwrap().pop().unwrap();let r = 0.5;diff --git a/crates/kernel/src/validity.rs b/crates/kernel/src/validity.rsindex 578331e162..73fdfe1437 100644--- a/crates/kernel/src/validity.rs+++ b/crates/kernel/src/validity.rs@@ -56,20 +56,12 @@ fn smlib_validity(body: &Body) -> Option<SmlibCheck> {/// Whether this build links SMLib (the `smlib` feature).pub fn smlib_built() -> bool {- cfg!(feature = "smlib")+ solidcraft_smlib::built()}-/// Where every SMLib call that fails from now on leaves its inputs for replay (the C API's-/// `smlib_set_dump_dir`: the call's arguments and B-reps, which `smlib_brep_read` reads back);-/// `None` stops it. A build without SMLib makes no calls to dump.+/// Where every kernel call that fails from now on leaves its inputs for replay+/// (`solidcraft_smlib::set_dump_dir`, on either kernel: the call and its B-reps, which `Brep::read`+/// reads back); `None` stops it.pub fn smlib_dump_dir(dir: Option<&std::path::Path>) -> crate::Result<()> {- #[cfg(feature = "smlib")]- {- solidcraft_smlib::set_dump_dir(dir).map_err(|e| crate::KernelError::Failed(format!("SMLib dump folder: {e}")))- }- #[cfg(not(feature = "smlib"))]- {- let _ = dir;- Ok(())- }+ solidcraft_smlib::set_dump_dir(dir).map_err(|e| crate::KernelError::Failed(format!("kernel dump folder: {e}")))}diff --git a/crates/smlib/Cargo.toml b/crates/smlib/Cargo.tomlindex 2647a9945b..bc849548ae 100644--- a/crates/smlib/Cargo.toml+++ b/crates/smlib/Cargo.toml@@ -20,14 +20,17 @@ type_complexity = "allow"neg_cmp_op_on_partial_ord = "allow"[features]-# Compile and link SMLib. Off, the crate builds without a C++ toolchain or the SMLib sources, and-# every call returns `Error::NotBuilt`, so workspace-wide builds and checks need neither.+# Compile and link the C++ SMLib (the apps' and the kernel's `smlib` feature turns it on; off by+# default). Off, the crate builds without a C++ toolchain, the SMLib sources or a prebuilt library,+# build.rs does nothing, solidcore answers every operation, and a call asked of the C++ kernel+# returns `Error::NotBuilt`.native = [][dependencies]log = { workspace = true }solidcraft-geom = { workspace = true }solidcraft-profile = { workspace = true }+solidcore = { workspace = true }[target.'cfg(target_arch = "wasm32")'.dependencies]# The clocks SMLib's C library asks for in a browser build (src/ffi.rs).diff --git a/crates/smlib/src/check.rs b/crates/smlib/src/check.rsindex a818a5b62f..13f940076c 100644--- a/crates/smlib/src/check.rs+++ b/crates/smlib/src/check.rs@@ -1,7 +1,7 @@//! SMLib's own validity check: `SmBrep::ValidatePointers`, then `AssertValid` over the whole//! topology graph. Tests run it on every SMLib result and every import.-use crate::{Brep, Error, Result, error, ffi};+use crate::{Brep, Error, Result, core, error, ffi, route};/// How many of SMLib's tests to run.#[derive(Clone, Copy, Debug, PartialEq, Eq)]@@ -53,13 +53,16 @@ impl Brep {/// Runs SMLib's validity check at `level`. A body that fails it is still `Ok`, with the/// failures in the report; `Err` means the check could not run.pub fn check(&self, level: CheckLevel) -> Result<CheckReport> {+ if route::backend() == route::Backend::Solidcore {+ return core::check(self.core()?, level);+ }let mut buf = vec![0u8; 1 << 16];- let (len, failures) = match ffi::check::check(&self.0, level as i32, &mut buf) {+ let (len, failures) = match ffi::check::check(self.cpp()?, level as i32, &mut buf) {Ok(r) => r,// Too long for the first buffer: once more with the length it asked for.Err((ffi::ERR_BUFFER, needed)) => {buf = vec![0u8; needed.saturating_add(1)];- ffi::check::check(&self.0, level as i32, &mut buf).map_err(|(s, _)| error(s))?+ ffi::check::check(self.cpp()?, level as i32, &mut buf).map_err(|(s, _)| error(s))?}Err((s, _)) => return Err(error(s)),};@@ -102,6 +105,7 @@ mod tests {#[test]fn a_copy_and_a_native_file_round_trip_stay_valid() {+ let _cpp = crate::route::on_cpp();let b = Brep::make_box([0.0; 3], [2.0, 3.0, 4.0]).unwrap();assert!(b.try_clone().unwrap().check(CheckLevel::All).unwrap().is_valid());let dir = std::env::temp_dir().join(format!("solidcraft-smlib-check-{}", std::process::id()));diff --git a/crates/smlib/src/core.rs b/crates/smlib/src/core.rsnew file mode 100644index 0000000000..5bbc56ac1f--- /dev/null+++ b/crates/smlib/src/core.rs@@ -0,0 +1,569 @@+//! The solidcore backend: one kernel for the process (SMLib's context is process-global too, and+//! some of its state, such as the fillet solver's latched step, lives for the whole process),+//! every call under its lock and a panic guard.+//!+//! Upstream fixes ([`fixes`]) are solidcore's opt-in corrections of SMLib defects that the C+++//! fork fixed in its own sources; each one turned on here says which fork commit it matches.++use std::panic::{AssertUnwindSafe, catch_unwind};+use std::sync::{Mutex, PoisonError};++use solidcore::geom::attribute::{AttributeStore, ObjectKey};+use solidcore::geom::vector3d::Vec3;+use solidcore::kernel::{Kernel, KernelOptions, UpstreamFixes};+use solidcore::mass::integrator::properties::{PropertyAttributes, brep_volume};+use solidcore::primitive::api_primitives as primitives;++use crate::{Error, Result};++pub(crate) mod blend;+#[cfg(test)]+mod blend_tests;+pub(crate) mod boolean;+#[cfg(test)]+mod boolean_tests;+mod convert;+#[cfg(test)]+mod convert_tests;+pub(crate) mod dump;+pub(crate) mod file;+pub(crate) mod history;+mod measure;+#[cfg(test)]+mod measure_tests;+pub(crate) mod merge;+#[cfg(test)]+mod merge_tests;+pub(crate) mod offset;+#[cfg(test)]+mod offset_tests;+pub(crate) mod split;+#[cfg(test)]+mod split_tests;+pub(crate) mod ssi;+pub(crate) mod sweep;+#[cfg(test)]+mod sweep_tests;+pub(crate) mod transform;+#[cfg(test)]+mod transform_tests;+pub(crate) mod trim;+#[cfg(test)]+mod trim_tests;++pub(crate) use convert::{from_arrays, to_arrays};+pub(crate) use measure::{area, bounds, check, classify_point, edge_face_distance, is_manifold_solid, mass_properties, solid_count};++/// A solidcore body. Its own lock: solidcore's operations take `&mut Brep`, even to measure.+pub(crate) struct Body(pub(crate) Mutex<solidcore::topology::Brep>);++impl Body {+ pub(crate) fn new(b: solidcore::topology::Brep) -> Body {+ Body(Mutex::new(b))+ }+}++/// The fixes this backend runs with: every one of solidcore's opt-in fixes of upstream SMLib+/// defects (`UpstreamFixes`, each naming its record and issue), whether or not the C++ fork has it,+/// unless it appears broken. A test checks none is left off but those in `HELD_BACK`, so moving the+/// solidcore pin to a rev with a new flag fails until it is added here.+pub(crate) fn fixes() -> UpstreamFixes {+ let mut f = UpstreamFixes::default();+ f.fillet_retry_radius_as_first = true;+ f.fillet_rail_rim_on_face = true;+ f.fillet_refuse_rails_leaving_faces = true;+ f.fillet_refuse_face_consuming_blends = true;+ f.fillet_refuse_non_manifold_result = true;+ f.fillet_vertex_error_diagnostics = true;+ f.fillet_corner_ball_patch = true;+ f.fillet_chamfer_cone_on_arc = true;+ f.fillet_torus_center_on_axis = true;+ f.offset_excess_faces_after_merge = true;+ f.offset_clip_right_side_out = true;+ f.revolution_offset_axis_both_sides = true;+ f.offset_extended_edges_mated = true;+ f.remove_slit_loops_where_solids_touch = true;+ f.keep_operand_uv_trims = true;+ f.proto_vertex_miss_is_false = true;+ f.check_loop_vertex_tolerance = true;+ f.check_loop_projected_seam_ends = true;+ f.trim_boundary_seam_wrap = true;+ f.bspline_check_min_radius = true;+ f.oscillating_skips_failed_guesses = true;+ f.refine_cc_range_ends = true;+ f.flat_corners_test_bits = true;+ f.cylinder_rebuild_mean_radius = true;+ f.planar_path_uncapped_open_profiles = true;+ f.revolve_analytic_profile_faces = true;+ f.revolve_arc_centre_near_axis_is_sphere = true;+ f.taper_pivot_nearest_corner = true;+ f.taper_tangent_corner_planes = true;+ f.revolve_nested_shells_as_cavities = true;+ f.revolve_holed_profile_void = true;+ f.curve_sweep_caps_at_sweep_ends = true;+ f.join_touching_loops = true;+ f.uv_trim_reversal_on_surface = true;+ f.offset_resolve_crossing_loops = true;+ f.offset_walls_touch_refused = true;+ f.offset_analytic_mate_edges = true;+ f.precise_properties_split_at_surface_knots = true;+ f.nurb_cylinder_inside_out_frame = true;+ f.shell_inner_shell_of_statuses = true;+ f.local_operation_offset_status = true;+ f.local_operation_refuses_loose_tangent_edges = true;+ f.torus_major_radius_from_origin = true;+ f.fillet_corner_sphere_from_four_arcs = true;+ f.fillet_nx1_opposite_continuation_side_edge = true;+ f.fillet_trace_rejects_short_step = true;+ f.torus_iso_circle_axis_from_midpoint = true;+ f.torus_keeps_inside_out = true;+ f.internal_pole_row_through_knot = true;+ f.extrusion_origin_scaled_zero = true;+ f.transform_scales_each_tolerance = true;+ f.transform_model_size_from_body_box = true;+ f.offset_collapsed_rounds_mated = true;+ f.offset_missing_surface_fails = true;+ f.fillet_nx1_end_rib_global_merge = true;+ f.uv_trim_corner_end_points_only = true;+ f.bspline_trim_preserves_uv_spans = true;+ f.cone_parallel_line_midpoint = true;+ f.cone_parallel_line_domains = true;+ f.proto_edge_self_loop_on_vertex_degenerate = true;+ f.slice_coincident_faces_sheet_side = true;+ f.boolean_outer_shell_first = true;+ f.edge_reversal_keeps_failed_edge = true;+ f.topology_failed_evaluations_propagate = true;+ f.heal_stage3_failures_propagate = true;+ f.sweep_frame_on_planar_path_normal = true;+ f.cover_refuses_folded_continuation = true;+ f.boolean_vertex_by_best_crossing = true;+ f.boolean_cleanup_removes_slits = true;+ f.classify_edge_interval = true;+ f.ellipse_trim_seam_lines_span_cone_height = true;+ f.degenerate_proto_edge_in_one_vertex = true;+ f.new_edge_vertex_tolerance_covers_gap = true;+ f.torus_signed_gen_curve_interval = true;+ f.sheet_sweep_joins_profile_wires = true;+ f.point_solve_keeps_triangle_guess = true;+ f.fillet_setback_from_start_vertex = true;+ f.imprint_trims_edge_to_proto_vertex = true;+ f.imprint_extends_edge_to_proto_vertex = true;+ f.fillet_point_step_per_point = true;+ f.analytic_copy_keeps_parameterization = true;+ f.fillet_point_bigger_step_retry = true;+ f.fillet_through_extended_rail_end = true;+ f.precise_properties_body_length_scale = true;+ f.offset_extension_from_base = true;+ f.corner_blend_stays_inside_neighbours = true;+ f.fillet_cleanup_keeps_target_faces = true;+ f.fillet_nx1_tangent_side_edge = true;+ f.fillet_3x2_mixed_concave_side_edge = true;+ f.offset_closed_curve_trim_arc = true;+ f.offset_stitch_at_body_tolerance = true;+ f.curve_contacts_at_curve_ends = true;+ f.shell_empty_cavity_fails = true;+ f.fillet_refuse_ball_not_fitting = true;+ f.boolean_lists_virtual_surface_copies = true;+ f.sphere_small_circle_not_touching = true;+ f.ssi_tangent_contact_points = true;+ f.ssi_trace_tangent_curves_once = true;+ f.ssi_singular_start_inside_direction = true;+ f.found_torus_sphere_keep_tested_nurb = true;+ f.boolean_skips_faces_apart = true;+ f.uv_trim_checks_on_surface = true;+ f.loop_orientation_floor_from_loop_box = true;+ f.offset_extends_cones_as_themselves = true;+ f.local_operation_box_holds_new_surfaces = true;+ f.uv_trim_joins_drop_pieces = true;+ f.shell_edges_on_analytics_exact = true;+ f.ssi_no_reverse_of_empty_trace = true;+ f.ssi_pole_point_keeps_its_tangent = true;+ f.iso_curve_sliver_domain_is_degenerate = true;+ f.corner_blend_coons_patch_tangent_to_sides = true;+ f.fillet_patch_keeps_fillet_edges = true;+ f.fillet_corner_ball_center_from_axes = true;+ f.seam_point_solutions_are_one = true;+ f.boolean2d_plane_covers_far_faces = true;+ f.brep_area_between_solid_and_void = true;+ f.boolean_splits_definition_across_split = true;+ f.curve_tight_box_interval_knots = true;+ f.fillet_refuse_overlapping_bands = true;+ f.ssi_tangent_curve_tracer = true;+ f.torus_check_reads_v_interval = true;+ f.torus_check_spindle_apex = true;+ f.local_operation_step_walls = true;+ f.edge_check_orders_tangent_faces = true;+ f.revolve_arc_touching_axis_is_horn_torus = true;+ f.thicken_planar_side_walls = true;+ f.fillet_torus_span_from_start_section = true;+ f.fillet_knife_edge_rounds = true;+ f.taper_wall_closes_at_apex = true;+ f.revolution_round_offset_collapses = true;+ f.fillet_chamfer_cone_stored_as_cone = true;+ f.offset_point_vertex_caps = true;+ f.approximate_surface_bezier_starter = true;+ f.proto_edge_splits_at_captured_vertices = true;+ f.stitch_solid_nests_cavities = true;+ f.local_operation_closes_walls_to_nothing = true;+ f.linear_sweep_arc_to_cylinder_zero = true;+ f.imprint_reuses_coincident_face_edge = true;+ f.boolean_new_face_closure_both_sides = true;+ f.linear_sweep_arc_is_cylinder = true;+ f.offset_closes_loop_gaps = true;+ f.cylinder_plane_tangent_within_tolerance = true;+ f.boolean_wire_edge_keeps_faceuse_shell = true;+ f.fillet_nx1_tangent_corner_edge = true;+ f.fillet_torus_rail_on_axis = true;+ f.loops_go_on_round_the_vertex = true;+ f.revolve_splits_curves_on_axis = true;+ f.cover_wraps_across_closed_seam = true;+ f.imprint_extension_keeps_analytic_curve = true;+ f.fillet_trace_from_tangent_point_toward_next = true;+ f.fillet_tangent_point_one_sided_step = true;+ f.fillet_rails_meet_at_one_end_point = true;+ f.fillet_trace_reaches_rails = true;+ f.delete_vertex_joins_seam_iso_curve = true;+ f.box_face_failures_propagate = true;+ f.ellipse_adjust_step_interval_keeps_turns = true;+ f.fillet_cleanup_removes_input_slits = true;+ f.fillet_rail_end_on_continued_surface = true;+ f.glue_vertices_joins_every_region = true;+ f.fillet_nx1_tangent_side_edge_same_convexity = true;+ f.fillet_removal_takes_ring_fillets = true;+ // The fork's commits that reached `SMLIB_REV` at eaa998a (tangency-labs/smlib#68, #69, #70).+ f.fillet_trim_inside_by_best_dot = true;+ f.fillet_half_degree_crease = true;+ f.fillet_split_edge_keeps_near_half = true;+ f.curve_loop_normal_from_area = true;+ // The fork's commits in `SMLIB_REV` 2fc375f, ported to solidcore since.+ f.fillet_cliff_overflow = true;+ f.fillet_3x2_tangent_side_edge_roles = true;+ f.offset_extension_as_itself = true;+ f.fillet_mitre_concave_face_corners = true;+ f.fillet_mitre_gap_patch = true;+ f.fillet_run_on_past_far_end_only = true;+ f.good_drop_result_distances_in_order = true;+ f.face_tight_box_searches_trim = true;+ f.ssi_low_angle_start_on_probation = true;+ f.fillet_variable_span_follows_fillet = true;+ f.simple_coincidence_crossing_is_point = true;+ f.boolean_temporary_transform_statuses = true;+ f.primitive_path_curve_statuses = true;+ f.planar_path_sweep_statuses = true;+ f.planar_path_profile_placement_statuses = true;+ f.fillet_trim_status = true;+ f.perspective_sphere_offsets = true;+ f.plane_recognition_origin_after_axes = true;+ f.fillet_corner_face_curve_halves = true;+ f.brep_edit_statuses_pass_on = true;+ f.fillet_run_on_bspline_trims = true;+ f.offset_tangent_gap_statuses = true;+ f.ssi_alignment_statuses = true;+ f.fillet_corner_statuses = true;+ f.fillet_edge_curve_domain_statuses = true;+ f.query_statuses_pass_on = true;+ f.sweep_statuses_pass_on = true;+ f.ssi_proto_topology_statuses_pass_on = true;+ f.analytic_inversion_answers_apart = true;+ f.fillet_statuses_pass_on = true;+ f.fillet_corner_per_vertex_fan = true;+ f.fillet_rail_trim_at_near_knot = true;+ f.offset_splits_corner_vertices = true;+ f.offset_keep_cavity_regions = true;+ f.offset_four_face_vertex_split = true;+ f.gap_samples_non_bspline_v_stride = true;+ f.gap_array_append_updates_longest = true;+ f.imprint_skips_collapsed_definition = true;+ f.precise_properties_trim_base_v = true;+ f.fillet_blend_curve_revolved_on_arc = true;+ f.temporary_radius_setup_errors = true;+ f.ellipse_step_interval_checks = true;+ f.corner_patch_face_side_twist = true;+ f.boolean_union_refuses_solid_leak = true;+ f.curve_loop_start_after_previous_end = true;+ f.loop_use_reports_open_gaps = true;+ f.face_points_span_domain = true;+ f.drop_curve_v_domain_degeneracy = true;+ f.mirror_curve_keeps_euclidean_control_points = true;+ f.fillet_corner_variable_radius_rail_on_opposite_fillet = true;+ f.sphere_from_arcs_common_centre = true;+ f.dupin_bottom_hyperbola_axis = true;+ f.extent3d_contains_both_segment_endpoints = true;+ f.translation_sweep_regularize = true;+ f.gap_samples_use_trimmed_spans = true;+ f.twist_simple_duw_sign = true;+ f.offset_swap_uv_extended_distance = true;+ f.circumscribe_axis_map_by_basis = true;+ f.planar_path_profile_in_path_frame = true;+ f.validation_does_not_make_uv_trims = true;+ f.iso_curve_uv_line_both_params = true;+ f.extrusion_step_uses_clamped_uv = true;+ f.analytic_corner_failure_is_false = true;+ f.defeature_refuses_open_base = true;+ f.ssi_start_loop_trace_budget = true;+ f.fillet_refuse_crossing_rails = true;+ f.proto_edge_split_upper_keeps_the_old_max = true;+ f.point_on_start_point_squared_tolerance = true;+ f.bspline_trim_keeps_rational_end_spans = true;+ f.fillet_exact_round_classes = true;+ f.curve_check_zero_speed_tangent_end = true;+ f.cpoly_remove_poly_face_check_member = true;+ f.check_seam_crossing_unclosed = true;+ f.ascii_doubles_round_trip = true;+ f.transform_aligned_bbox_image = true;+ f.bspline_simple_offset_matches_parameterization = true;+ f.offset_edges_keep_source_tolerance = true;+ f.best_fit_line_largest_scatter_eigenvector = true;+ f.circle_silhouette_perspective_center = true;+ f.ellipse_convert_to_2d_uses_both_axes = true;+ f.circle_offset_antiparallel_normal = true;+ f.masked_array_uses_bit_shift = true;+ f.global_solver_identical_prefers_larger_when_maximizing = true;+ f.surface_continuity_checks_last_v_knot = true;+ f.surface_point_solver_propagates_bbox_failure = true;+ f.volume_lift_third_derivative_terms = true;+ f.volume_discontinuity_checks_vw_unaligned = true;+ f.periodic_extent_add_empty_interval = true;+ f.stop_tracking_checks_own_callback = true;+ f.plane_reparameterize_moves_origin = true;+ f.crv_in_volume_mults_by_break_index = true;+ f.curve_bounded_surface_read_uv_type_and_implicit_outer = true;+ f.polar_box_region_to_arc_transposes_domain = true;+ f.point_set_centroid_all_blocks = true;+ f.local_solve1d_unbounded_newton_step = true;+ f.composite_curve_bbox_segment_intervals = true;+ f.knot_vector_valid_requires_span = true;+ f.projected_curve_transform_when_owned = true;+ f.curve_property_gs_branch_bounds = true;+ f.volume_representational_end_continuities = true;+ f.integrator_propagates_failure = true;+ f.precise_properties_span_end_from_below = true;+ f.offset_open_edge_second_trim_point = true;+ f.close_loop_relates_only_coincident_edges = true;+ f.ssi_split_curves_at_singular_points = true;+ f.surface_parallel_to_vector_checks = true;+ f.fillet_round_ends_at_tangent_continuation = true;+ f.geometric_g2_continuity = true;+ f.hash_table_grow_preserves_removed_records = true;+ f.bend_volume_bbox_contains_wide_angle_and_inf_u = true;+ f.bend_volume_trim_param_box_across_period = true;+ f.point_set_tight_pbox_projects_points = true;+ f.degen_param_tiebreak_uses_actual_param = true;+ f.conic_evaluate_uses_computed_second_deriv = true;+ f.cylinder_plane_section_trims_exact = true;+ f.local_surface_intersect_guards_max_boundary_retry = true;+ f.curve_max_distance_single_sample_midpoint = true;+ f.curve_sweep_closed_path_joins_ends = true;+ f.validate_tolerances_fixes_reported_gaps = true;+ f.edgeuse_convexity_propagates_step_off_failure = true;+ f.mark_lock_pair_advances_and_locks_second_context = true;+ f.is_iso_curve_at_propagates_canonical_failure = true;+ f.database_io_byte_swaps_read_boolean_and_u16 = true;+ f.is_point_on_curve_propagates_eval_failure = true;+ f.is_topological_vertex_rejects_cusps_and_tangent_errors = true;+ f.cone_create_canonical_preserves_inside_out_and_checks_height = true;+ f.point_class_gap_3d_propagates_no_drop_error = true;+ f.fillet_surface_plane_curve_on_plane_equation = true;+ f.fillet_extended_rail_end_at_side_edge_crossing = true;+ f.fillet_gn_section_generator = true;+ f.face_trim_curves_kept_where_exact = true;+ f.swap_uv_keeps_analytic_definition = true;+ f.face_shrink_bound_on_knot = true;+ f.offset_updates_result_tolerances = true;+ f.cone_iso_circle_at_axial_height = true;+ f.boolean_coincident_strip_drops_crossing = true;+ f.fillet_overflow_trim_at_creases = true;+ f.fillet_section_end_trim_at_creases = true;+ f+}++/// The fixes held off, each with the case and the numbers that show it broken: a volume or topology+/// wrong against the analytic value, a check failure, a crash, sound geometry refused that builds+/// without the flag, or a large slowdown. Differing from the C++ kernel is no such evidence: a fix+/// the fork doesn't have stays on, and where solidcore builds what SMLib refuses, a result right+/// against its closed form is a win.+#[cfg(test)]+const HELD_BACK: &[&str] = &[];++fn fresh() -> Kernel {+ let mut k = Kernel::new(&KernelOptions::default());+ k.fixes = fixes();+ k+}++pub(crate) static KERNEL: Mutex<Option<Kernel>> = Mutex::new(None);++/// Runs `f` on the process's kernel. A panic in solidcore is caught: the kernel, which it may have+/// left half-updated, is replaced by a fresh one and the call fails with [`Error::Internal`].+pub(crate) fn run<T: dump::Answer>(call: &'static str, f: impl FnOnce(&mut Kernel) -> std::result::Result<T, solidcore::SolidError>) -> Result<T> {+ let mut guard = KERNEL.lock().unwrap_or_else(PoisonError::into_inner);+ let k = guard.get_or_insert_with(fresh);+ // A profiler span per call, as the C API's calls are: where the kernel's time goes.+ let _span = solidcraft_profile::span("solidcore", call);+ #[cfg(test)]+ crate::route::reached_core();+ dump::begin();+ dump::set_current(Some(call));+ let r = match catch_unwind(AssertUnwindSafe(|| f(k))) {+ Ok(Ok(v)) => Ok(v),+ Ok(Err(e)) => Err(Error::Solidcore(format!("{call}: {e}"))),+ Err(p) => {+ *guard = Some(fresh());+ let why = p.downcast_ref::<&str>().map(|s| (*s).to_owned()).or_else(|| p.downcast_ref::<String>().cloned()).unwrap_or_default();+ log::warn!(target: "smlib", "solidcore panicked in {call}: {why}");+ Err(Error::Internal(format!("{call}: {why}")))+ }+ };+ dump::set_current(None);+ match &r {+ Ok(v) => {+ if let Some(why) = v.refusal() {+ dump::failed(call, &why);+ }+ }+ Err(e) => dump::failed(call, &e.to_string()),+ }+ r+}++/// A call the capi checks for `SM_SUCCESS`, treating any other status as no answer: an error+/// that stands for an SMLib status exactly ([`SolidError::sm_status`](solidcore::SolidError::sm_status),+/// solidcore#1452) is `None`. Every other solidcore error+/// (unported code, invalid input to an adapter, a missing record...) is not a status the C+++/// path returns, so it fails the call instead of hiding as a skipped entity.+pub(crate) fn answer<T>(r: std::result::Result<T, solidcore::SolidError>) -> std::result::Result<Option<T>, solidcore::SolidError> {+ match r {+ Ok(v) => Ok(Some(v)),+ Err(e) if e.sm_status().is_some() => Ok(None),+ Err(e) => Err(e),+ }+}++/// Runs `f` on the kernel and `body`, locking the kernel first.+pub(crate) fn with_body<T: dump::Answer>(+ call: &'static str,+ body: &Body,+ f: impl FnOnce(&mut Kernel, &mut solidcore::topology::Brep) -> std::result::Result<T, solidcore::SolidError>,+) -> Result<T> {+ // A body a panic interrupted may be half-edited: it is never used again.+ if body.0.is_poisoned() {+ return Err(Error::Internal(format!("{call}: the body was left unfinished by an earlier panic")));+ }+ run(call, |k| {+ let mut b = body.0.lock().unwrap_or_else(PoisonError::into_inner);+ dump::input(k, "brep", &b);+ f(k, &mut b)+ })+}++/// An axis-aligned box from its lower corner (`SmApiCreateBox`, as `smlib_make_box` checks it:+/// every edge length positive).+pub(crate) fn make_box(origin: [f64; 3], size: [f64; 3]) -> Result<Body> {+ if !origin.iter().chain(&size).all(|x| x.is_finite()) || !size.iter().all(|&s| s > 0.0) {+ return Err(Error::Argument);+ }+ let [x, y, z] = size;+ run("create_box", |k| primitives::create_box(k, Vec3::new(origin[0], origin[1], origin[2]), x, y, z)).map(Body::new)+}++fn point(p: [f64; 3]) -> Result<Vec3> {+ if !p.iter().all(|x| x.is_finite()) {+ return Err(Error::Argument);+ }+ Ok(Vec3::new(p[0], p[1], p[2]))+}++/// A cylinder about +Z from its base centre (`SmApiCreateCylinder`, as `smlib_make_cylinder`+/// checks it: radius and height positive).+pub(crate) fn make_cylinder(origin: [f64; 3], radius: f64, height: f64) -> Result<Body> {+ let o = point(origin)?;+ if !(radius > 0.0 && height > 0.0 && radius.is_finite() && height.is_finite()) {+ return Err(Error::Argument);+ }+ run("create_cylinder", |k| primitives::create_cylinder(k, o, radius, height)).map(Body::new)+}++/// A sphere (`SmApiCreateSphere`; radius positive).+pub(crate) fn make_sphere(center: [f64; 3], radius: f64) -> Result<Body> {+ let o = point(center)?;+ if !(radius > 0.0 && radius.is_finite()) {+ return Err(Error::Argument);+ }+ run("create_sphere", |k| primitives::create_sphere(k, o, radius)).map(Body::new)+}++/// A cone or frustum about +Z (`SmApiCreateCone`; `smlib_make_cone`'s checks: base radius and+/// height positive, top radius at least 0 and not the base radius).+pub(crate) fn make_cone(origin: [f64; 3], base_radius: f64, top_radius: f64, height: f64) -> Result<Body> {+ let o = point(origin)?;+ let ok = base_radius > 0.0 && top_radius >= 0.0 && height > 0.0 && top_radius != base_radius;+ if !(ok && base_radius.is_finite() && top_radius.is_finite() && height.is_finite()) {+ return Err(Error::Argument);+ }+ run("create_cone", |k| primitives::create_cone(k, o, base_radius, top_radius, height)).map(Body::new)+}++/// A ring torus about +Z (`SmApiCreateTorus`; major radius > minor radius > 0).+pub(crate) fn make_torus(center: [f64; 3], major_radius: f64, minor_radius: f64) -> Result<Body> {+ let o = point(center)?;+ if !(minor_radius > 0.0 && minor_radius < major_radius && major_radius.is_finite()) {+ return Err(Error::Argument);+ }+ run("create_torus", |k| primitives::create_torus(k, o, major_radius, minor_radius)).map(Body::new)+}++/// The enclosed volume (`SmApiBrepComputeVolume`).+pub(crate) fn volume(body: &Body, relative_accuracy: f64) -> Result<f64> {+ if !relative_accuracy.is_finite() {+ return Err(Error::Argument);+ }+ with_body("brep_volume", body, |k, b| {+ let store = AttributeStore::default();+ let attrs = PropertyAttributes { store: &store, key_of: &|_| ObjectKey(0) };+ brep_volume(k, b, relative_accuracy, &attrs)+ })+}++/// Face, edge and vertex counts.+pub(crate) fn counts(body: &Body) -> Result<[usize; 3]> {+ with_body("counts", body, |_, b| Ok([b.face_list().len(), b.edge_list().len(), b.vertex_list().len()]))+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn every_upstream_fix_is_on_unless_shown_broken() {+ let f = fixes();+ let flags: Vec<(&str, bool)> = f.flags().collect();+ let off: Vec<&str> = flags.iter().filter(|(name, on)| !on && !HELD_BACK.contains(name)).map(|(name, _)| *name).collect();+ assert!(off.is_empty(), "UpstreamFixes flags are off: {off:?}");+ for name in HELD_BACK {+ assert!(flags.contains(&(*name, false)), "{name} is on or gone: drop it from HELD_BACK");+ }+ }++ #[test]+ fn a_box_measures_exactly() {+ let b = make_box([1.0, -2.0, 3.0], [10.0, 20.0, 30.0]).unwrap();+ assert_eq!(counts(&b).unwrap(), [6, 12, 8]);+ let v = volume(&b, 1e-8).unwrap();+ assert!((v - 6000.0).abs() < 6000.0 * 1e-9, "{v}");+ }++ #[test]+ fn hostile_numbers_are_refused() {+ assert!(make_box([f64::NAN, 0.0, 0.0], [1.0; 3]).is_err());+ assert!(make_box([0.0; 3], [1.0, -1.0, 1.0]).is_err());+ let b = make_box([0.0; 3], [1.0; 3]).unwrap();+ assert!(volume(&b, f64::INFINITY).is_err());+ }++ #[test]+ fn a_panic_is_an_error_and_the_kernel_is_fresh_after() {+ let r: Result<()> = run("test", |_| panic!("boom"));+ assert!(matches!(r, Err(Error::Internal(ref m)) if m.contains("boom")), "{r:?}");+ assert!(make_box([0.0; 3], [1.0; 3]).is_ok());+ }+}diff --git a/crates/smlib/src/core/blend.rs b/crates/smlib/src/core/blend.rsnew file mode 100644index 0000000000..f6a1e5035a--- /dev/null+++ b/crates/smlib/src/core/blend.rs@@ -0,0 +1,1306 @@+//! Fillets and chamfers on solidcore: the C API's composition round SMLib's fillet executive,+//! ported from the fork's `capi/src/smlib_ops.cpp` (`blend_call`, `round_edges`,+//! `chamfer_offsets`, `chamfer_edges`, `chamfer_radius`, `outer_faceuse`, `face_frame`,+//! `sides_offsets`, `blend_failure`, `setbacks_fit`, `overflow_first`, `Picked`,+//! `size_ok`, `points_ok`, `tolerance_ok`, `law_ok`, `law_pinches`, `law_along`, `finish`,+//! `smlib_fillet`, `smlib_chamfer`, `smlib_blend`, `smlib_blend_dropping`, `smlib_blend_setback`,+//! `smlib_blend_setback_open`, `smlib_fillet_variable`, `smlib_chamfer_sides`) and+//! `capi/src/smlib_pick.h` (`pick`, `pick_edges`, `pick_vertices`).+//!+//! As there, every operation works on a copy of its body (`SmApiBrepCopy`), picks edges and+//! corners by point, and drives the executive step by step (`SetFilletParameters`,+//! `CreateFilletCorners`, the corners' bevels and setbacks, `DoFilleting`, `StitchAndOrient`).+//!+//! What the capi asks of fork-only SMLib code that solidcore does not have is+//! [`Error::Unsupported`], refused where the capi would first reach it, so every error before+//! it is the C++ path's:+//! - a variable radius whose law has a corner (`SplitFilletFacesAtRadiusCorners`, fork 6eecf04; solidcore#430, PR #1403).+//!+//! solidcore's own refusals of code it has not ported (`SolidError::Unported`) are+//! [`Error::Unsupported`] too.++use std::collections::{HashMap, HashSet};+use std::sync::PoisonError;++use solidcore::EntityRef;+use solidcore::SolidError;+use solidcore::blend::fillet_executive::p1::{FilletLaw, FilletLawKind};+use solidcore::blend::fillet_executive::p3::NoRoomReason;+use solidcore::blend::fillet_executive::session::FilletSession;+use solidcore::blend::fillet_geom::p1::{FilletCornerType, FilletErrorType};+use solidcore::blend::fillet_section::section::GN_THUMBWEIGHT_EQUAL_AREA;+use solidcore::blend::fillet_solver::p1::FilletSurfaceGeneratorType;+use solidcore::geom::attribute::{Attribute, AttributeHandlers, Behavior, ids as attribute_ids};+use solidcore::geom::vector3d::{Point3, Vec3};+use solidcore::kernel::Kernel;+use solidcore::mass::integrator::properties::edge_length;+use solidcore::nurbs::b_spline_curve::p1::{BSplineCurve, BSplineCurveForm, CanonicalData, KnotType};+use solidcore::nurbs::b_spline_surface_n_lib::p2::OrientType;+use solidcore::query::api_queries::edge_closest_point;+use solidcore::query::brep::evaluate_surface_normal;+use solidcore::topology::brep::p1 as brep_p1;+use solidcore::topology::brep::p2 as brep_p2;+use solidcore::topology::brep::p2::ArenaNotifyState;+use solidcore::topology::brep::p3::{DeleteFaceOptions, delete_face};+use solidcore::topology::brep::p5::{StitchAndOrientOptions, stitch_and_orient};+use solidcore::topology::edgeuse::p1 as eu_p1;+use solidcore::topology::edgeuse::p3::{BinormalOptions, evaluate_binormal};+use solidcore::topology::face::p2 as face_p2;+use solidcore::topology::face::p4 as face_p4;+use solidcore::topology::topology_traverser::Marks;+use solidcore::topology::{Brep, EdgeId, EdgeuseId, FaceId, FaceuseId, VertexId, edge, vertex};++use super::{Body, answer, run};+use crate::{Blend, ChamferSecond, Error, Hole, HoleEdge, MAX_POINTS, Result};+use solidcore::topology::brep::p3::brep_copy;++/// The capi's statuses as SolidCraft errors: an operation's own result.+type Out<T> = std::result::Result<T, Error>;++/// `SM_ERR_INVALID_INPUT`.+const INVALID_INPUT: i32 = 1007;++/// An SMLib status as the capi passes it on (`status`, smlib_shim.h): solidcore's upstream+/// status codes as they are; its refusals of code it has not ported as not supported.+pub(super) fn status(e: SolidError) -> Error {+ match e {+ SolidError::Upstream { code, .. } => Error::Status(code),+ SolidError::InvalidInput { .. } => Error::Status(INVALID_INPUT),+ e if e.is_unported() => Error::Unsupported,+ e => Error::Solidcore(e.to_string()),+ }+}++/// `size_ok`.+fn size_ok(x: f64) -> bool {+ x.is_finite() && x > 0.0 && x <= 1e6+}++/// `tolerance_ok`.+pub(super) fn tolerance_ok(t: f64) -> bool {+ t.is_finite() && t > 0.0 && t < 1e6+}++/// `points_ok`.+pub(super) fn points_ok(points: &[[f64; 3]], allow_none: bool) -> bool {+ points.len() <= MAX_POINTS && (allow_none || !points.is_empty()) && points.iter().flatten().all(|x| x.is_finite())+}++pub(super) fn p3(p: [f64; 3]) -> Point3 {+ Vec3::new(p[0], p[1], p[2])+}++/// Why a pick failed: `SMLIB_ERR_PICK_NONE` or `SMLIB_ERR_PICK_AMBIGUOUS`, and the point.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(super) enum Miss {+ None(usize),+ Ambiguous(usize),+}++/// `smlib_pick::pick`: the entity nearest each point, each once, with the index of the point that+/// first picked it. A point picks none when the nearest is farther than `tol`, and is ambiguous+/// when the second nearest is within `tol` too and nearer than the first by at most `model_tol`.+/// An entity whose distance query returns a status other than success is skipped, as the capi+/// skips it ([`answer`]); any other solidcore error fails the pick.+pub(super) fn pick<T: Copy + PartialEq>(+ all: &[T],+ points: &[[f64; 3]],+ tol: f64,+ model_tol: f64,+ mut dist: impl FnMut(T, Point3) -> solidcore::Result<Option<f64>>,+) -> solidcore::Result<std::result::Result<(Vec<T>, Vec<usize>), Miss>> {+ let (mut picked, mut first) = (Vec::new(), Vec::new());+ for (i, p) in points.iter().enumerate() {+ let p = p3(*p);+ let (mut best, mut d0, mut d1) = (None, f64::INFINITY, f64::INFINITY);+ for &x in all {+ let Some(d) = dist(x, p)? else { continue };+ if !d.is_finite() {+ continue;+ }+ if d < d0 {+ d1 = d0;+ d0 = d;+ best = Some(x);+ } else if d < d1 {+ d1 = d;+ }+ }+ let Some(best) = best.filter(|_| d0 <= tol) else {+ return Ok(Err(Miss::None(i)));+ };+ if d1 <= tol && d1 - d0 <= model_tol {+ return Ok(Err(Miss::Ambiguous(i)));+ }+ if !picked.contains(&best) {+ picked.push(best);+ first.push(i);+ }+ }+ Ok(Ok((picked, first)))+}++/// `pick_edges` (`edge_distance`: `SmApiEdgeClosestPoint`).+pub(super) fn pick_edges(+ k: &Kernel,+ b: &Brep,+ points: &[[f64; 3]],+ tol: f64,+) -> solidcore::Result<std::result::Result<(Vec<EdgeId>, Vec<usize>), Miss>> {+ let all = brep_p1::edges(b, None)?;+ pick(&all, points, tol, b.tolerance(), |e, p| Ok(answer(edge_closest_point(k, b, e, p))?.map(|c| c.closest.distance)))+}++/// `pick_vertices` (`vertex_distance`).+fn pick_vertices(b: &Brep, points: &[[f64; 3]], tol: f64) -> solidcore::Result<std::result::Result<(Vec<VertexId>, Vec<usize>), Miss>> {+ let all = brep_p1::vertices(b, None)?;+ pick(&all, points, tol, b.tolerance(), |v, p| Ok(Some((b.vertex(v)?.point - p).length())))+}++/// An edge pick's failure as `pick_error` (ops.rs) reads it.+pub(super) fn edge_miss(m: Miss) -> Error {+ match m {+ Miss::None(point) => Error::NoMatch { point },+ Miss::Ambiguous(point) => Error::Ambiguous { point },+ }+}++/// A corner pick's failure as `setback_error` (ops.rs) reads it: the capi writes the corner+/// point's index to `out_failed_corner` only, so the status comes back bare.+fn corner_miss(m: Miss) -> Error {+ match m {+ Miss::None(_) => Error::Status(crate::ffi::ops::ERR_PICK_NONE),+ Miss::Ambiguous(_) => Error::Status(crate::ffi::ops::ERR_PICK_AMBIGUOUS),+ }+}++/// A corner set back: its vertex and the setback along each of its edges (the capi's+/// `SetBack`; the entry points take no ease, which is 0).+struct SetBack {+ vertex: VertexId,+ distance: f64,+}++/// `setbacks_fit`: each setback shorter than every edge at its corner, and where an edge's+/// other end is a setback corner too, the two together shorter than the edge.+fn setbacks_fit(k: &Kernel, b: &Brep, setbacks: &[SetBack]) -> solidcore::Result<bool> {+ for sb in setbacks {+ for e in vertex::edges(b, sb.vertex, None)? {+ let Some(length) = answer(edge_length(k, b, e, 1e-6))? else {+ return Ok(false);+ };+ let far = edge::other_vertex(b, e, Some(sb.vertex))?;+ let mut other = 0.0;+ for o in setbacks {+ if Some(o.vertex) == far && far != Some(sb.vertex) {+ other = o.distance;+ }+ }+ if sb.distance + other >= length {+ return Ok(false);+ }+ }+ }+ Ok(true)+}++/// The midpoint parameter of `e` (`GetInterval().Evaluate(0.5)`).+fn mid(b: &Brep, e: EdgeId) -> solidcore::Result<f64> {+ Ok(b.edge(e)?.interval.evaluate(0.5))+}++/// `chamfer_radius`: the radius of the ball whose tangent points on the two faces of `e` lie+/// `distance` back from the edge at its midpoint, `distance * tan(a / 2)` with `a` the angle+/// between the directions into the faces; at a cusp (a knife edge) `distance` itself, the ball+/// whose contacts the chamfer joins. `None` where the capi's returns false.+fn chamfer_radius(k: &Kernel, b: &mut Brep, e: EdgeId, distance: f64) -> solidcore::Result<Option<f64>> {+ let Some(u0) = edge::blend_edgeuse(k, b, e)? else { return Ok(None) };+ let Some(u1) = eu_p1::radial(b, u0)? else { return Ok(None) };+ let t = mid(b, e)?;+ let options = BinormalOptions::default();+ let Some(e0) = answer(evaluate_binormal(k, b, u0, t, false, &options))? else { return Ok(None) };+ let Some(e1) = answer(evaluate_binormal(k, b, u1, t, false, &options))? else { return Ok(None) };+ // Unitize's failure (a zero vector) is the capi's `return false`.+ let (Ok(n0), Ok(b0), Ok(b1)) = (e0.face_normal.unitize(), e0.binormal.unitize(), e1.binormal.unitize()) else { return Ok(None) };+ let c = b0.dot(b1).clamp(-1.0, 1.0);+ // At a cusp (a knife edge: the faces tangent within the half degree `GetBlendEdgeuse` calls+ // tangent, folded back on each other, the binormals the same way) a is 0 and no ball lies+ // `distance` back along both: the chamfer is the chord between the contacts of the ball of+ // radius `distance` (fork e96898d).+ let cusp = c > 0.0 && b1.dot(n0).abs() < (0.5 * std::f64::consts::PI / 180.0).sin();+ let radius = if cusp { distance } else { distance * ((1.0 - c) / (1.0 + c)).sqrt() };+ Ok((radius.is_finite() && radius > 0.0).then_some(radius))+}++/// What `round_edges` makes: the capi's kinds less the chamfer, which `chamfer_offsets` makes.+#[derive(Clone, Copy, PartialEq)]+enum Section<'a> {+ Round,+ /// The curvature-continuous section (`SM_FSG_BLEND_CURVE`): the Gⁿ generator's order 2 at the+ /// equal-area thumbweight (`SMLIB_BLEND_THUMBWEIGHT`, fork 6148773; solidcore#2261 under+ /// `fillet_gn_section_generator`), which takes off what the ball's circle does.+ Curvature,+ Chord,+ /// A chamfer, with each edge's offset of its second surface (`chamfer_offsets`' `second`;+ /// the sizes are the first's).+ Chamfer(&'a [f64]),+}++/// The faces of `b`, for `made_faces`: a face whose id is new after the operation was made by+/// it. (The capi marks faces with an attribute SMLib copies through every split; here a face+/// split by the operation counts as made, which only matters to a blend that made no blend+/// face but split one, never seen.)+fn face_set(b: &Brep) -> solidcore::Result<HashSet<FaceId>> {+ Ok(brep_p1::faces(b, None)?.into_iter().collect())+}++/// `blend_failure`: a blend the executive found larger than its faces allow+/// (`SM_FILERR_NO_ROOM`) is [`Error::NoRoom`]; a filleted vertex no corner type handles+/// (`SM_FILERR_CORNER_UNSUPPORTED`, which solidcore notes under+/// `fixes.fillet_vertex_error_diagnostics`) is [`Error::CornerUnsupported`]; any other failure+/// its status. `corner` says `CreateFilletCorners` noted such a vertex: the corner it could not+/// make is why a later step fails, so that note stands for it whatever the later step noted+/// (as solidcore's own `FilletSession::do_fillet` keeps it).+///+/// Except a blend whose rail leaves its face refused as [`NoRoomReason::RailLeavesFace`]: that+/// is solidcore without `fixes.fillet_cliff_overflow`, refusing every such blend where the fork+/// decides between building it over the cliff (`SmFilletCliffOverflow.cpp`, fork 8ba4667) and+/// refusing it. Its answer is the fork's only by chance, so it is [`Error::Unsupported`]. With+/// the cliff overflow on, solidcore makes the fork's choice, and its refusals (each with its own+/// reason) are [`Error::NoRoom`] like the fork's.+fn blend_failure(s: &FilletSession<'_>, e: SolidError, corner: bool) -> Error {+ let info = s.error_info();+ if e.is_unported() {+ status(e)+ } else if corner || info.code == FilletErrorType::CornerUnsupported as i32 {+ Error::CornerUnsupported+ } else if info.code != FilletErrorType::NoRoom as i32 {+ status(e)+ } else if info.no_room_reason() == Some(NoRoomReason::RailLeavesFace) {+ Error::Unsupported+ } else {+ Error::NoRoom+ }+}++/// `round_edges`' `overflow_first` argument: with it the session stops, nothing built, when blends+/// of several edges overflow their faces across cliffs (`SetOverflowFirst`) or (`classify_only`)+/// always (`SetClassifyOnly`), and `stopped` gets the edges whose blends overflow+/// (`GetOverflowEdges`; the capi's status `OVERFLOW_FIRST`, the call's failure then meaning only that)+/// and `mitred` the edges of each two rounds mitred at a face's concave corner, two by two+/// (`GetMitredEdges`), when the caller asks.+struct OverflowFirst<'a> {+ classify_only: bool,+ stopped: &'a mut Option<Vec<EdgeId>>,+ mitred: Option<&'a mut Vec<EdgeId>>,+}++/// `round_edges` and `chamfer_offsets` (with equal offsets): `edges` of `b` blended in place,+/// edge i at `sizes[i]`, the executive driven as `SmApiFilletEdgesPerEdge` drives it with the+/// corners' setbacks (`SmFilletCorner::SetSetBackDist`) set between making the corners and+/// filleting, or (a chamfer) every corner bevelled; then `StitchAndOrient`. A blend that made+/// no face is [`Error::NoEffect`]. A setback corner that is not SMLib's same-convexity N x N+/// corner is refused with its index in `setbacks` (`Err(Ok(j))`).+///+/// With `patches`, the session marks the set-back corners' patches (`SetMarkCornerPatches`, fork+/// 60af574), and after the stitch `patches` gets each corner's, in `setbacks`' order: the faces+/// marked with its index, in the body's face order. A corner whose patch has no face is+/// [`Error::Unsupported`].+fn blend_edges(+ k: &mut Kernel,+ b: &mut Brep,+ edges: &[EdgeId],+ sizes: &[f64],+ section: Section<'_>,+ law: Option<FilletLaw>,+ setbacks: &[SetBack],+ patches: Option<&mut Vec<Vec<FaceId>>>,+) -> solidcore::Result<std::result::Result<(), std::result::Result<usize, Error>>> {+ blend_edges_stopping(k, b, edges, sizes, section, law, setbacks, patches, None)+}++/// [`blend_edges`], with `round_edges`' `overflow_first` argument.+#[allow(clippy::too_many_arguments)] // the capi's round_edges+fn blend_edges_stopping(+ k: &mut Kernel,+ b: &mut Brep,+ edges: &[EdgeId],+ sizes: &[f64],+ section: Section<'_>,+ law: Option<FilletLaw>,+ setbacks: &[SetBack],+ patches: Option<&mut Vec<Vec<FaceId>>>,+ overflow_first: Option<OverflowFirst<'_>>,+) -> solidcore::Result<std::result::Result<(), std::result::Result<usize, Error>>> {+ let before = face_set(b)?;+ let done = {+ let mut s = FilletSession::new(k, b)?;+ // `SetFilletParameters(b, es, sections, solvers, values, laws, -1, -1, -1, -1,+ // continuity 1, thumbweight 1)`: the session sets the executive's global merge first, as+ // `SmApiFilletEdges` does, and `SetFilletParameters` resets it, as in the capi.+ let prepared = match (section, law) {+ (Section::Round, None) => s.prepare_per_edge_constant_radius(k, edges, sizes, &[FilletSurfaceGeneratorType::Circular], 1, 1.0),+ // The size is the start radius (`smlib_fillet_variable`).+ (Section::Round, Some(law)) => match sizes.first() {+ Some(&size) => s.prepare_variable_radius_edges(k, edges, size, law, 1, 1),+ None => return Ok(Err(Err(Error::Argument))),+ },+ // The equal-area thumbweight by solidcore's name, never its value: solidcore#2274 moves+ // it from -2 to 2, after which -2 is an ordinary weight.+ (Section::Curvature, _) => {+ s.prepare_per_edge_constant_radius(k, edges, sizes, &[FilletSurfaceGeneratorType::BlendCurve], 2, GN_THUMBWEIGHT_EQUAL_AREA)+ }+ (Section::Chord, _) => s.prepare_per_edge_constant_distance(k, edges, sizes, &[FilletSurfaceGeneratorType::Circular], 1, 1.0),+ (Section::Chamfer(second), _) => chamfer_parameters(k, &mut s, edges, sizes, second),+ };+ let mut step = prepared.and_then(|()| s.create_corners(k, None)).map(|()| Ok(Vec::new()));+ // A vertex `CreateFilletCorners` made no corner for, noted before a later step notes its+ // own failure over it ([`blend_failure`]).+ let corner = step.is_ok() && s.error_info().code == FilletErrorType::CornerUnsupported as i32;+ s.set_overflow_first(overflow_first.is_some());+ s.set_classify_only(overflow_first.as_ref().is_some_and(|o| o.classify_only));+ if let Ok(Ok(_)) = step {+ step = corners(&mut s, section, setbacks);+ }+ s.set_mark_corner_patches(patches.is_some());+ match step {+ // The marks go with the session: read them before it drops.+ Ok(Ok(set_back)) => match s.do_filleting(k, None) {+ Ok(()) => s.corner_patch_faces().map(|marked| Ok((set_back, marked))),+ Err(e) => {+ if let Some(o) = overflow_first+ && s.error_info().code == FilletErrorType::OverflowFirst as i32+ {+ *o.stopped = Some(s.overflow_edges());+ if let Some(m) = o.mitred {+ *m = s.mitred_edges();+ }+ }+ Ok(Err(Err(blend_failure(&s, e, corner))))+ }+ },+ Ok(Err(refusal)) => Ok(Err(refusal)),+ Err(e) => Ok(Err(Err(blend_failure(&s, e, corner)))),+ }+ };+ let done: solidcore::Result<std::result::Result<(Vec<usize>, Vec<(usize, FaceId)>), std::result::Result<usize, Error>>> = done;+ let (set_back, marked) = match done? {+ Ok(d) => d,+ Err(refusal) => {+ b.refresh_cached_topology();+ return Ok(Err(refusal));+ }+ };+ let stitched = stitch_and_orient(k, b, &StitchAndOrientOptions::default()).map_err(status);+ // The port's cached topology, true again for what reads the body next (as solidcore's own+ // fillet entry points do).+ b.refresh_cached_topology();+ if let Err(e) = stitched {+ return Ok(Err(Err(e)));+ }+ let made = face_set(b)?.difference(&before).count();+ if made == 0 {+ return Ok(Err(Err(Error::NoEffect)));+ }+ if let Some(patches) = patches {+ // The stitch keeps the faces filleting made: a corner's patch is the faces marked with+ // its index.+ let live = brep_p1::faces(b, None)?;+ let marked: HashMap<FaceId, usize> = marked.into_iter().map(|(i, f)| (f, i)).collect();+ for &index in &set_back {+ let patch: Vec<FaceId> = live.iter().copied().filter(|f| marked.get(f) == Some(&index)).collect();+ if patch.is_empty() {+ return Ok(Err(Err(Error::Unsupported)));+ }+ patches.push(patch);+ }+ // `RemoveAttributeFromTopology(SM_AI_FILLET_CORNER_FACE)`: the marks are the session's,+ // and none is left on the body's own faces.+ for f in live {+ let at = EntityRef::Face(f);+ let marks: Vec<_> =+ b.entity_attributes(at).into_iter().filter(|(_, a)| a.attribute_id() == attribute_ids::FILLET_CORNER_FACE).map(|(h, _)| h).collect();+ for h in marks {+ b.remove_attribute(at, h)?;+ }+ }+ }+ Ok(Ok(()))+}++/// `chamfer_offsets`' `SetFilletParameters(b, es, kinds, solvers, first, NULL, -1, -1, -1, -1,+/// 1, 1.0, &second)` with every kind `SM_FSG_LINEAR` and every solver `SM_FS_CONST_RADIUS`, as the+/// fork's `SetFilletParameters` runs it (its `pOptSecondRadii`, fork f653ac9).+fn chamfer_parameters(k: &mut Kernel, s: &mut FilletSession<'_>, edges: &[EdgeId], first: &[f64], second: &[f64]) -> solidcore::Result<()> {+ if edges.is_empty() {+ return Ok(());+ }+ s.prepare_per_edge_constant_radius_with_second(k, edges, first, second, &[FilletSurfaceGeneratorType::Linear], 1, 1.0)+}++/// The corners' part of `round_edges` / `chamfer_offsets`: a chamfer's corners bevelled; each+/// setback set on its vertex's corner (`GetFilletCornerOfVertex`), which must be an+/// `SM_FCR_N_x_N_CONVEX` corner. Each set-back corner's index in the session's corners, in+/// `setbacks`' order.+fn corners(+ s: &mut FilletSession<'_>,+ section: Section<'_>,+ setbacks: &[SetBack],+) -> solidcore::Result<std::result::Result<Vec<usize>, std::result::Result<usize, Error>>> {+ let ids = s.fillet_corners()?;+ if matches!(section, Section::Chamfer(_)) {+ for id in ids {+ s.set_corner_bevel(id, true)?;+ }+ return Ok(Ok(Vec::new()));+ }+ let mut set_back = Vec::with_capacity(setbacks.len());+ for (j, sb) in setbacks.iter().enumerate() {+ let mut found = None;+ for (i, &id) in ids.iter().enumerate() {+ if s.corner(id)?.vertex == Some(sb.vertex) {+ found = Some((i, id));+ break;+ }+ }+ let Some((i, id)) = found else {+ return Ok(Err(Err(Error::Argument)));+ };+ if s.corner(id)?.corner_type() != FilletCornerType::NByNConvex {+ return Ok(Err(Ok(j)));+ }+ s.set_corner_setback(id, sb.distance)?;+ set_back.push(i);+ }+ Ok(Ok(set_back))+}++/// `finish`: the result must have faces, and a solid input must give a closed manifold solid.+pub(super) fn finish(b: Brep, solid_in: bool) -> solidcore::Result<Out<Brep>> {+ if b.face_list().is_empty() {+ return Ok(Err(Error::Empty));+ }+ if solid_in && !brep_p2::is_manifold_solid(&b)? {+ return Ok(Err(Error::NotSolid));+ }+ Ok(Ok(b))+}++/// Runs `f` on a copy of `body` (`brep_copy`) under the kernel's lock.+pub(super) fn on_copy(call: &'static str, body: &Body, f: impl FnOnce(&mut Kernel, Brep) -> solidcore::Result<Out<Brep>>) -> Result<Body> {+ if body.0.is_poisoned() {+ return Err(Error::Internal(format!("{call}: the body was left unfinished by an earlier panic")));+ }+ run(call, |k| {+ let g = body.0.lock().unwrap_or_else(PoisonError::into_inner);+ super::dump::input(k, "brep", &g);+ let c = brep_copy(k, &g)?;+ drop(g);+ f(k, c)+ })?+ .map(Body::new)+}++/// What [`blend`] does with the picked corners' patches.+#[derive(Clone, Copy, PartialEq, Eq)]+pub(crate) enum Corners {+ /// Filled, as SMLib builds them (`smlib_blend`, `smlib_blend_setback`).+ Filled,+ /// Removed, the holes listed (`smlib_blend_setback_open`).+ Open,+}++/// `Picked::ID`: above SMLib's own ids (`SM_AI_USER_1 + 9`).+const PICKED_ID: u64 = attribute_ids::USER_1 + 9;++/// The capi's `Picked`: which picked edge an edge stands for, put on the picked edges before an+/// overflowing blend goes first, handed on through every split and copy (`SM_AB_COPY`), so+/// afterwards the edges carrying it are what the overflow left of that picked edge (none: it+/// removed the edge whole).+#[derive(Debug, Clone, PartialEq)]+struct Picked(usize);++impl AttributeHandlers for Picked {}++/// The attribute `Picked` on `e`, with its handle.+fn picked_on(b: &Brep, e: EdgeId) -> Option<(solidcore::geom::attribute::AttributeHandle, usize)> {+ let (h, a) = b.entity_attributes(EntityRef::Edge(e)).into_iter().find(|(_, a)| a.attribute_id() == PICKED_ID)?;+ a.application_value::<Picked>().map(|p| (h, p.0))+}++/// Whether the rounds that overflow go first ([`overflow_first`]): on since solidcore#1980, which+/// keeps the attributes of the target edges the subtraction replaces, so a picked edge the overflow+/// only shortened still reads as picked.+const OVERFLOW_GOES_FIRST: bool = true;++/// `overflow_first`: the rounds of [`blend_call`] when blends of several edges overflow their+/// faces (`round_edges` stopped in the copy `w` of `body`, `picked` its picked edges, `each` their+/// sizes). The blends that overflow on their own (each edge's alone, classified in `w`, which+/// nothing was built in) go first: on a fresh copy of `body`, the picked edges tagged with their+/// places ([`Picked`]), those are rounded, and each other picked edge is then what is left of it,+/// the edges carrying its tag, rounded at its size. A picked edge with nothing left is gone: its+/// points are flagged in `dropped`. Two rounds mitred at a face's concave corner (`mitred`, the edges+/// of each such pair two by two, as the stopped call found them in `w`) meet in their mitre, each run+/// on past the corner: one goes first with the other, so a round mitred to one that overflows goes+/// first too (fork 9ba2b12). Where none overflows on its own, or all go first, the edges are rounded+/// together as before. The result is the new body. Unlike the capi, the tags come off it+/// (nothing reads them after the call, and a later call's copy would carry them on).+#[allow(clippy::too_many_arguments)] // the capi's overflow_first+fn overflow_first(+ k: &mut Kernel,+ body: &Body,+ points: &[[f64; 3]],+ tolerance: f64,+ section: Section<'_>,+ picked: &[EdgeId],+ mitred: &[EdgeId],+ each: &[f64],+ w: &mut Brep,+ dropped: &mut [bool],+) -> solidcore::Result<Out<Brep>> {+ /// A failure of `round_edges` on the fresh copy, which has no setback corners.+ fn failed(e: std::result::Result<usize, Error>) -> Error {+ e.err().unwrap_or(Error::Unsupported)+ }+ let mut fresh = {+ let g = body.0.lock().unwrap_or_else(PoisonError::into_inner);+ brep_copy(k, &g)?+ };+ let again = match pick_edges(k, &fresh, points, tolerance)? {+ Ok((again, _)) if again.len() == picked.len() => again,+ Ok(_) => return Ok(Err(Error::NoMatch { point: 0 })),+ Err(m) => return Ok(Err(edge_miss(m))),+ };+ let mut goes_first = vec![false; picked.len()];+ for (i, ((&e, &to), &size)) in picked.iter().zip(&again).zip(each).enumerate() {+ let mut stopped = None;+ let alone = OverflowFirst { classify_only: true, stopped: &mut stopped, mitred: None };+ match blend_edges_stopping(k, w, &[e], &[size], section, None, &[], None, Some(alone))? {+ Err(Err(why)) if stopped.is_none() => return Ok(Err(why)),+ Err(Ok(_)) => return Ok(Err(Error::Unsupported)),+ Ok(()) => return Ok(Err(Error::Status(1001))),+ Err(Err(_)) => {}+ }+ fresh.add_attribute(EntityRef::Edge(to), Attribute::application(PICKED_ID, Behavior::Copy, Picked(i)))?;+ if let Some(flag) = goes_first.get_mut(i) {+ *flag = stopped.is_some_and(|over| !over.is_empty());+ }+ }+ // A round mitred to one that goes first goes with it, through every mitre.+ let place = |e: &EdgeId| picked.iter().position(|p| p == e);+ let pairs: Vec<(usize, usize)> = mitred.as_chunks::<2>().0.iter().filter_map(|[a, b]| Some((place(a)?, place(b)?))).collect();+ let mut grew = true;+ while grew {+ grew = false;+ for &(a, b) in &pairs {+ if goes_first.get(a) != goes_first.get(b) {+ for i in [a, b] {+ if let Some(flag) = goes_first.get_mut(i) {+ *flag = true;+ }+ }+ grew = true;+ }+ }+ }+ let (mut lead, mut lead_sizes, mut rest) = (Vec::new(), Vec::new(), Vec::new());+ for (i, ((&to, &size), &first)) in again.iter().zip(each).zip(&goes_first).enumerate() {+ if first {+ lead.push(to);+ lead_sizes.push(size);+ } else {+ rest.push(i);+ }+ }+ if lead.is_empty() || rest.is_empty() {+ return Ok(match blend_edges(k, &mut fresh, &again, each, section, None, &[], None)? {+ Ok(()) => untagged(fresh),+ Err(e) => Err(failed(e)),+ });+ }+ if let Err(e) = blend_edges(k, &mut fresh, &lead, &lead_sizes, section, None, &[], None)? {+ return Ok(Err(failed(e)));+ }+ let edges = brep_p1::edges(&fresh, None)?;+ let (mut rest_edges, mut rest_sizes) = (Vec::new(), Vec::new());+ for i in rest {+ let mut left = false;+ for &e in &edges {+ if picked_on(&fresh, e).is_some_and(|(_, p)| p == i) {+ rest_edges.push(e);+ rest_sizes.push(each.get(i).copied().unwrap_or(0.0));+ left = true;+ }+ }+ if !left {+ // Every point that picked edge i (in `w`, which nothing was built in).+ for (j, p) in points.iter().enumerate() {+ if let (Ok((one, _)), Some(flag)) = (pick_edges(k, w, std::slice::from_ref(p), tolerance)?, dropped.get_mut(j))+ && one.as_slice() == picked.get(i..=i).unwrap_or_default()+ {+ *flag = true;+ }+ }+ }+ }+ if !rest_edges.is_empty()+ && let Err(e) = blend_edges(k, &mut fresh, &rest_edges, &rest_sizes, section, None, &[], None)?+ {+ return Ok(Err(failed(e)));+ }+ Ok(untagged(fresh))+}++/// `b` with [`Picked`] off its edges.+fn untagged(mut b: Brep) -> Out<Brep> {+ let edges = brep_p1::edges(&b, None).map_err(status)?;+ for e in edges {+ if let Some((h, _)) = picked_on(&b, e) {+ b.remove_attribute(EntityRef::Edge(e), h).map_err(status)?;+ }+ }+ Ok(b)+}++/// Why a curvature fillet over edges of different wedge angles is refused. The equal-area+/// thumbweight is resolved once per call, from the first blend's wedge, and every edge takes it+/// (in the fork as in solidcore#2261): an edge of another wedge takes off another area than its+/// own, and which one depends on the edges' order.+pub(crate) const CURVATURE_MIXED_WEDGES: &str = "a curvature-continuous fillet on solidcore over edges whose faces meet at different \+angles: every edge takes the equal-area thumbweight of the first one's angle, so the others take off the wrong area \+(https://github.com/tangency-labs/solidcore/issues/2250#issuecomment-6563419897)";++/// How far apart, in radians, two edges' wedge angles may be and still share one equal-area+/// thumbweight.+const WEDGE_TOLERANCE: f64 = 1e-6;++/// Whether the faces of every edge in `edges` meet at the same angle at its midpoint (the wedge the+/// equal-area thumbweight is resolved from), within [`WEDGE_TOLERANCE`]. An edge whose angle can't+/// be read counts as another wedge.+fn one_wedge(k: &Kernel, b: &mut Brep, edges: &[EdgeId]) -> solidcore::Result<bool> {+ let mut first: Option<f64> = None;+ for &e in edges {+ let Some(u0) = edge::blend_edgeuse(k, b, e)? else { return Ok(false) };+ let Some(u1) = eu_p1::radial(b, u0)? else { return Ok(false) };+ let (Some((n0, _)), Some((n1, _))) = (face_frame(k, b, u0)?, face_frame(k, b, u1)?) else { return Ok(false) };+ let angle = n0.dot(n1).clamp(-1.0, 1.0).acos();+ match first {+ None => first = Some(angle),+ Some(a) if (a - angle).abs() > WEDGE_TOLERANCE => return Ok(false),+ Some(_) => {}+ }+ }+ Ok(true)+}++/// [`blend_holes`] without its holes.+#[allow(clippy::too_many_arguments)] // the capi's blend_call+pub(crate) fn blend(+ body: &Body,+ kind: Blend,+ points: &[[f64; 3]],+ sizes: &[f64],+ tolerance: f64,+ corners: &[[f64; 3]],+ setbacks: &[f64],+ open: Corners,+) -> Result<Body> {+ blend_holes(body, kind, points, sizes, tolerance, corners, setbacks, open).map(|(b, _)| b)+}++/// `smlib_blend_dropping`: [`blend`] with one size per point, no corners, and per point whether it+/// picked an edge that a larger round, overflowing its faces, removed whole.+pub(crate) fn blend_dropping(body: &Body, kind: Blend, points: &[[f64; 3]], sizes: &[f64], tolerance: f64) -> Result<(Body, Vec<bool>)> {+ let mut dropped = vec![false; points.len()];+ let (b, _) = blend_call(body, kind, points, sizes, tolerance, &[], &[], Corners::Filled, &mut dropped)?;+ Ok((b, dropped))+}++/// `blend_call` (as `smlib_fillet`, `smlib_chamfer`, `smlib_blend`, `smlib_blend_setback` and+/// `smlib_blend_setback_open` call it): `sizes` one per point, or one for all; `corners` and+/// `setbacks` the corner setbacks. With [`Corners::Open`], the holes, one per point of+/// `corners` (none otherwise).+#[allow(clippy::too_many_arguments)] // the capi's blend_call+pub(crate) fn blend_holes(+ body: &Body,+ kind: Blend,+ points: &[[f64; 3]],+ sizes: &[f64],+ tolerance: f64,+ corners: &[[f64; 3]],+ setbacks: &[f64],+ open: Corners,+) -> Result<(Body, Vec<Hole>)> {+ blend_call(body, kind, points, sizes, tolerance, corners, setbacks, open, &mut vec![false; points.len()])+}++/// `blend_call`: [`blend_holes`], with per point in `dropped` whether it picked an edge an+/// overflowing round removed whole ([`overflow_first`]).+#[allow(clippy::too_many_arguments)] // the capi's blend_call+fn blend_call(+ body: &Body,+ kind: Blend,+ points: &[[f64; 3]],+ sizes: &[f64],+ tolerance: f64,+ corners: &[[f64; 3]],+ setbacks: &[f64],+ open: Corners,+ dropped: &mut [bool],+) -> Result<(Body, Vec<Hole>)> {+ let one_size = sizes.len() == 1;+ if !points_ok(points, false)+ || !tolerance_ok(tolerance)+ || !(one_size || sizes.len() == points.len())+ || !points_ok(corners, true)+ || setbacks.len() != corners.len()+ {+ return Err(Error::Argument);+ }+ if !sizes.iter().all(|&s| size_ok(s)) || !setbacks.iter().all(|&s| size_ok(s)) {+ return Err(Error::Argument);+ }+ // A chamfer's corners are bevelled, which builds no setback.+ if !corners.is_empty() && kind == Blend::Chamfer {+ return Err(Error::Unsupported);+ }+ let mut holes = Vec::new();+ let made = on_copy("blend_call", body, |k, mut w| {+ let (picked, first) = match pick_edges(k, &w, points, tolerance)? {+ Ok(p) => p,+ Err(m) => return Ok(Err(edge_miss(m))),+ };+ let each: Vec<f64> = first.iter().map(|&i| sizes.get(if one_size { 0 } else { i }).copied().unwrap_or(0.0)).collect();+ // Each corner point picks a vertex; a vertex picked twice takes the first point's setback.+ let (at, first_corner) = match pick_vertices(&w, corners, tolerance)? {+ Ok(p) => p,+ Err(m) => return Ok(Err(corner_miss(m))),+ };+ let back: Vec<SetBack> =+ at.iter().zip(&first_corner).map(|(&vertex, &j)| SetBack { vertex, distance: setbacks.get(j).copied().unwrap_or(0.0) }).collect();+ if !setbacks_fit(k, &w, &back)? {+ return Ok(Err(Error::NoRoom));+ }+ let solid_in = brep_p2::is_manifold_solid(&w)?;+ let section = match kind {+ Blend::Round => Section::Round,+ // Every edge of one call takes the equal-area thumbweight of the first's wedge+ // (solidcore#2250's comment 6563419897): edges of other wedges would take off another+ // area than their own, so they are not built together.+ Blend::Curvature if !one_wedge(k, &mut w, &picked)? => return Ok(Err(Error::Unported(CURVATURE_MIXED_WEDGES))),+ Blend::Curvature => Section::Curvature,+ Blend::Chord => Section::Chord,+ // `chamfer_edges`: each edge's offsets from its setback at its midpoint.+ Blend::Chamfer => {+ let mut radii = Vec::with_capacity(picked.len());+ for (&e, &d) in picked.iter().zip(&each) {+ match chamfer_radius(k, &mut w, e, d)? {+ Some(r) => radii.push(r),+ None => return Ok(Err(Error::Status(INVALID_INPUT))),+ }+ }+ return Ok(match blend_edges(k, &mut w, &picked, &radii, Section::Chamfer(&radii), None, &[], None)? {+ Ok(()) => finish(w, solid_in)?,+ Err(Ok(_)) => Err(Error::Unsupported),+ Err(Err(e)) => Err(e),+ });+ }+ };+ // The corners' places, read now: filleting deletes the vertices.+ let at_points = at.iter().map(|&v| vertex::point(&w, v)).collect::<solidcore::Result<Vec<Point3>>>()?;+ let mut patches = Vec::new();+ // An overflow goes first (rounds without corner setbacks): when some of the rounds+ // overflow their faces across cliffs and others fit, the overflowing ones are built+ // first, on a fresh copy, and the others then round what is left of their edges. An edge+ // the overflow removes whole is gone (`dropped`); one it cuts keeps the rest.+ let may_go_first = OVERFLOW_GOES_FIRST && back.is_empty() && open == Corners::Filled && picked.len() > 1;+ let (mut stopped, mut mitred) = (None, Vec::new());+ let first = may_go_first.then_some(OverflowFirst { classify_only: false, stopped: &mut stopped, mitred: Some(&mut mitred) });+ let done = blend_edges_stopping(k, &mut w, &picked, &each, section, None, &back, (open == Corners::Open).then_some(&mut patches), first)?;+ if stopped.is_some() {+ return Ok(match overflow_first(k, body, points, tolerance, section, &picked, &mitred, &each, &mut w, dropped)? {+ Ok(fresh) => finish(fresh, solid_in)?,+ Err(e) => Err(e),+ });+ }+ match done {+ Ok(()) => {}+ // A corner SMLib does not set back: the first of the caller's points that picked it.+ Err(Ok(j)) => return Ok(Err(first_corner.get(j).map_or(Error::Unsupported, |&corner| Error::CornerRefused { corner }))),+ Err(Err(e)) => return Ok(Err(e)),+ }+ if open == Corners::Filled {+ return finish(w, solid_in);+ }+ // Each corner opened: its patch removed, the edges round its hole in the result's+ // orders, once per corner point (a vertex picked twice gives its hole twice).+ if !brep_p2::is_manifold_solid(&w)? {+ return Ok(Err(Error::NotSolid));+ }+ let rims = match open_corners(k, &mut w, &patches)? {+ Ok(r) => r,+ Err(e) => return Ok(Err(e)),+ };+ let edge_index: HashMap<EdgeId, usize> = brep_p1::edges(&w, None)?.into_iter().enumerate().map(|(i, e)| (e, i)).collect();+ let face_index: HashMap<FaceId, usize> = brep_p1::faces(&w, None)?.into_iter().enumerate().map(|(i, f)| (f, i)).collect();+ for c in corners {+ let p = Point3::new(c[0], c[1], c[2]);+ let mut which = None;+ let mut best = f64::INFINITY;+ for (j, q) in at_points.iter().enumerate() {+ let d = (*q - p).length();+ if d < best {+ best = d;+ which = Some(j);+ }+ }+ let Some(rim) = which.and_then(|j| rims.get(j)) else { return Ok(Err(Error::Argument)) };+ let mut edges = Vec::with_capacity(rim.len());+ for h in rim {+ let (Some(&edge), Some(&face)) = (edge_index.get(&h.edge), face_index.get(&h.face)) else { return Ok(Err(Error::Unsupported)) };+ edges.push(HoleEdge { edge, face, forward: h.forward });+ }+ holes.push(Hole { edges });+ }+ finish(w, false)+ })?;+ Ok((made, holes))+}++/// One edge round an opened corner's hole (`HoleEdge`): the face beside it, and whether that+/// face's boundary, run counter-clockwise about its outward normal (the solid's), runs the edge+/// from its start vertex to its end.+#[derive(Clone, Copy)]+struct RimEdge {+ edge: EdgeId,+ face: FaceId,+ forward: bool,+}++/// `open_corners`: the faces of each patch in `patches` removed from the solid `b`, with the edges+/// and vertices only they used, and the edges round each patch's hole, as the faces beside it run+/// them, each edge's start the previous one's end. Read on the solid before anything is removed,+/// where each face's outward side is known. Each edge round a hole must lie between a face of its+/// patch and one other face, outside every patch, and the edges must close one loop (a patch that+/// is a disc), else [`Error::Unsupported`].+fn open_corners(k: &mut Kernel, b: &mut Brep, patches: &[Vec<FaceId>]) -> solidcore::Result<Out<Vec<Vec<RimEdge>>>> {+ let any: HashSet<FaceId> = patches.iter().flatten().copied().collect();+ let mut holes = Vec::with_capacity(patches.len());+ for patch in patches {+ let mine: HashSet<FaceId> = patch.iter().copied().collect();+ let mut seen = HashSet::new();+ let mut rim: Vec<RimEdge> = Vec::new();+ for &f in patch {+ for e in face_p4::edges(b, f, None, false, None)? {+ if !seen.insert(e) {+ continue;+ }+ let beside = edge::faces(b, e, None)?;+ let mut outside = beside.iter().copied().filter(|g| !mine.contains(g));+ let (Some(other), more) = (outside.next(), outside.next()) else { continue };+ if more.is_some() || beside.len() != 2 || any.contains(&other) {+ return Ok(Err(Error::Unsupported));+ }+ let Some(fu) = outer_faceuse(b, other)? else { return Ok(Err(Error::Unsupported)) };+ let mut used = None;+ for u in edge::edgeuses(b, e, None, None)? {+ if eu_p1::faceuse(b, u)? == Some(fu) {+ used = Some(u);+ }+ }+ let Some(u) = used else { return Ok(Err(Error::Unsupported)) };+ rim.push(RimEdge { edge: e, face: other, forward: b.edgeuse(u)?.orientation == OrientType::Same });+ }+ }+ let ends = |h: &RimEdge| -> solidcore::Result<(Option<VertexId>, Option<VertexId>)> {+ let (s, t) = edge::start_end_vertices(b, h.edge)?;+ Ok(if h.forward { (s, t) } else { (t, s) })+ };+ let Some(&front) = rim.first() else { return Ok(Err(Error::Unsupported)) };+ let start = ends(&front)?.0;+ let mut used = vec![false; rim.len()];+ if let Some(u) = used.first_mut() {+ *u = true;+ }+ let mut hole = vec![front];+ let mut end = ends(&front)?.1;+ // Each turn takes a rim edge not yet in the hole, so it ends within the rim's length.+ while end != start {+ let mut next = None;+ for (i, h) in rim.iter().enumerate() {+ if !used.get(i).copied().unwrap_or(true) && ends(h)?.0 == end {+ if next.is_some() {+ return Ok(Err(Error::Unsupported));+ }+ next = Some((i, *h));+ }+ }+ let Some((i, h)) = next else { return Ok(Err(Error::Unsupported)) };+ if let Some(u) = used.get_mut(i) {+ *u = true;+ }+ hole.push(h);+ end = ends(&h)?.1;+ }+ if hole.len() != rim.len() {+ return Ok(Err(Error::Unsupported));+ }+ holes.push(hole);+ }+ // `DeleteFace(f, TRUE)` with the B-rep open for editing, each face once, in the patches'+ // order.+ let mut order = Vec::with_capacity(any.len());+ let mut taken = HashSet::new();+ for &f in patches.iter().flatten() {+ if taken.insert(f) {+ order.push(f);+ }+ }+ let editing = b.editing_enabled();+ b.set_editing_enabled(true);+ let mut deleted = Ok(());+ {+ let mut state = ArenaNotifyState::new(b);+ let mut env = state.env(None);+ let mut marks = Marks::default();+ for f in order {+ let options = DeleteFaceOptions { delete_edges_vertices: true, ..DeleteFaceOptions::default() };+ if let Err(e) = delete_face(k, b, &mut env, &mut marks, f, options) {+ deleted = Err(e);+ break;+ }+ }+ }+ b.set_editing_enabled(editing);+ b.refresh_cached_topology();+ Ok(match deleted {+ Ok(()) => Ok(holes),+ Err(e) => Err(status(e)),+ })+}++/// The faceuse of `f` on the outside of its body (`outer_faceuse`): the one bounding the+/// infinite region (for a sheet, the upward one).+fn outer_faceuse(b: &Brep, f: FaceId) -> solidcore::Result<Option<FaceuseId>> {+ let Some(fu) = face_p2::upward_faceuse(b, f)? else { return Ok(None) };+ let shell = b.faceuse(fu)?.shell;+ let region = match shell {+ Some(sh) => b.shell(sh)?.region,+ None => None,+ };+ if shell.is_none() || region != b.infinite_region() { Ok(b.faceuse(fu)?.mate) } else { Ok(Some(fu)) }+}++/// `face_frame`: the outward unit normal, at the edge's midpoint, of the face the edge use `u`+/// bounds, and the unit direction into that face square to the edge.+fn face_frame(k: &Kernel, b: &mut Brep, u: EdgeuseId) -> solidcore::Result<Option<(Vec3, Vec3)>> {+ let Some(e) = b.edgeuse(u)?.edge else { return Ok(None) };+ let fu_of_lu = match eu_p1::loopuse(b, u)? {+ Some(lu) => b.loopuse(lu)?.faceuse,+ None => None,+ };+ let f = match fu_of_lu {+ Some(fu) => b.faceuse(fu)?.face,+ None => None,+ };+ let Some(f) = f else { return Ok(None) };+ let Some(fu) = outer_faceuse(b, f)? else { return Ok(None) };+ if b.face(f)?.surface.is_none() {+ return Ok(None);+ }+ let t = mid(b, e)?;+ let Some(at) = answer(evaluate_binormal(k, b, u, t, false, &BinormalOptions::default()))? else { return Ok(None) };+ let Some(normal) = answer(evaluate_surface_normal(k, b.face(f)?.surface.as_ref(), at.uv))? else { return Ok(None) };+ let len = normal.length();+ if !(len > 0.0 && len.is_finite()) {+ return Ok(None);+ }+ let sign = if b.faceuse(fu)?.orientation == OrientType::Same { 1.0 } else { -1.0 };+ Ok(Some((normal * (sign / len), at.binormal)))+}++/// `sides_offsets`: the surface offsets of `e` (its blend edge use's surface first) at which+/// `chamfer_offsets` cuts a chamfer `d1` back along the face whose outward normal at the edge's+/// midpoint leans most along `up`, and `second` back along the other (or at the angle `second`+/// to the first face). With b0, b1 the directions into the faces and θ the angle between them,+/// setbacks s0, s1 lie at offsets r0 = (s1 - s0 cos θ) / sin θ and r1 = (s0 - s1 cos θ) / sin θ;+/// an angle φ to the first face gives s1 = s0 sin φ / sin(θ + φ).+fn sides_offsets(k: &Kernel, b: &mut Brep, e: EdgeId, d1: f64, second: ChamferSecond, up: Vec3) -> solidcore::Result<Option<(f64, f64)>> {+ let Some(u0) = edge::blend_edgeuse(k, b, e)? else { return Ok(None) };+ let Some(u1) = eu_p1::radial(b, u0)? else { return Ok(None) };+ let (Some((n0, b0)), Some((n1, b1))) = (face_frame(k, b, u0)?, face_frame(k, b, u1)?) else { return Ok(None) };+ let c = b0.dot(b1).clamp(-1.0, 1.0);+ let sn = (1.0 - c * c).max(0.0).sqrt();+ if !(sn > 1e-6) {+ return Ok(None);+ }+ let mut s0 = d1;+ let mut s1 = match second {+ ChamferSecond::Distance(d) => d,+ ChamferSecond::Angle(phi) => {+ let d = (c.acos() + phi).sin();+ if !(d > 1e-9) {+ return Ok(None);+ }+ d1 * phi.sin() / d+ }+ };+ if n1.dot(up) > n0.dot(up) {+ std::mem::swap(&mut s0, &mut s1);+ }+ let (r0, r1) = ((s1 - s0 * c) / sn, (s0 - s1 * c) / sn);+ Ok((r0.is_finite() && r1.is_finite() && r0 > 0.0 && r1 > 0.0).then_some((r0, r1)))+}++/// `smlib_chamfer_sides`: the edges nearest `points` chamfered `distance` back along the face+/// whose outward normal leans most along `first`, and by `second` on the other, with bevelled+/// corners.+pub(crate) fn chamfer_sides(body: &Body, points: &[[f64; 3]], tolerance: f64, distance: f64, second: ChamferSecond, first: [f64; 3]) -> Result<Body> {+ let second_ok = match second {+ ChamferSecond::Angle(a) => a.is_finite() && a > 1e-6 && a < std::f64::consts::PI - 1e-6,+ ChamferSecond::Distance(d) => size_ok(d),+ };+ if !points_ok(points, false) || !tolerance_ok(tolerance) || !size_ok(distance) || !second_ok || !first.iter().all(|x| x.is_finite()) {+ return Err(Error::Argument);+ }+ let up = p3(first);+ if !(up.length() > 0.0) {+ return Err(Error::Argument);+ }+ on_copy("smlib_chamfer_sides", body, |k, mut w| {+ let picked = match pick_edges(k, &w, points, tolerance)? {+ Ok((p, _)) => p,+ Err(m) => return Ok(Err(edge_miss(m))),+ };+ let solid_in = brep_p2::is_manifold_solid(&w)?;+ let (mut r0, mut r1) = (Vec::with_capacity(picked.len()), Vec::with_capacity(picked.len()));+ for &e in &picked {+ match sides_offsets(k, &mut w, e, distance, second, up)? {+ Some((a, b)) => {+ r0.push(a);+ r1.push(b);+ }+ None => return Ok(Err(Error::Status(INVALID_INPUT))),+ }+ }+ Ok(match blend_edges(k, &mut w, &picked, &r0, Section::Chamfer(&r1), None, &[], None)? {+ Ok(()) => finish(w, solid_in)?,+ Err(Ok(_)) => Err(Error::Unsupported),+ Err(Err(e)) => Err(e),+ })+ })+}++/// `law_ok`: a clamped B-spline of `degree` 1 to 3 from 0 to 1, 2 to 100 control radii, each+/// finite, at least 0 and at most 1e6.+fn law_ok(degree: usize, knots: &[f64], radii: &[f64]) -> bool {+ let n = radii.len();+ if !(1..=3).contains(°ree) || !(2..=100).contains(&n) || n <= degree || knots.len() != n + degree + 1 {+ return false;+ }+ if !knots.iter().chain(radii).all(|x| x.is_finite()) {+ return false;+ }+ for (i, &k) in knots.iter().enumerate() {+ let (low_end, high_end) = (i <= degree, i >= n);+ if (low_end && k != 0.0) || (high_end && k != 1.0) || (i > 0 && knots.get(i - 1).is_some_and(|&p| k < p)) {+ return false;+ }+ }+ radii.iter().all(|&r| (0.0..=1e6).contains(&r))+}++/// `law_pinches`: whether the law's radius is zero somewhere inside (0, 1).+fn law_pinches(degree: usize, knots: &[f64], radii: &[f64]) -> bool {+ let n = radii.len() as i64;+ let p = degree as i64;+ let all_zero = |from: i64, to: i64| -> bool {+ let lo = from.max(0);+ let mut j = lo;+ while j <= to && j < n {+ if radii.get(j as usize).is_some_and(|&r| r != 0.0) {+ return false;+ }+ j += 1;+ }+ from <= to+ };+ let kn = |i: i64| knots.get(i as usize).copied().unwrap_or(f64::NAN);+ let n_knots = n + p + 1;+ let mut i = p;+ while i + 1 < n_knots && i < n {+ if kn(i) < kn(i + 1) && all_zero(i - p, i) {+ return true;+ }+ i += 1;+ }+ let mut s = p + 1;+ while s < n {+ let mut m = 1;+ while s + m < n && kn(s + m) == kn(s) {+ m += 1;+ }+ if all_zero(s + m - 1 - p, s - 1) {+ return true;+ }+ s += m;+ }+ false+}++/// Whether the law has a corner inside (0, 1) (`SmBSplineFilletLaw::GetCornerParameters`, fork+/// 6eecf04): an interior knot where the radius' slope from the left and from the right differ by+/// more than `SM_EFF_ZERO * (1 + |left| + |right|)`. The slope is the derivative B-spline's,+/// `Q_i = p (r_{i+1} - r_i) / (u_{i+p+1} - u_{i+1})`; it jumps only at a knot repeated `m >= p`+/// times, from `Q_{s-2}` to `Q_{s+m-1-p}` (`s` the knot's first index).+fn law_has_corner(degree: usize, knots: &[f64], radii: &[f64]) -> bool {+ const EFF_ZERO: f64 = 1e-12;+ let p = degree;+ let q = |i: usize| -> Option<f64> {+ let (r0, r1) = (radii.get(i)?, radii.get(i + 1)?);+ let span = knots.get(i + p + 1)? - knots.get(i + 1)?;+ Some(p as f64 * (r1 - r0) / span)+ };+ let n = radii.len();+ let mut s = p + 1;+ while s < n {+ let Some(&u) = knots.get(s) else { break };+ let mut m = 1;+ while knots.get(s + m) == Some(&u) {+ m += 1;+ }+ if m >= p && u > 0.0 && u < 1.0 {+ let (Some(left), Some(right)) = (s.checked_sub(2).and_then(q), q(s + m - 1 - p)) else {+ return true;+ };+ if (left - right).abs() > EFF_ZERO * (1.0 + left.abs() + right.abs()) {+ return true;+ }+ }+ s += m;+ }+ false+}++/// `law_along`: the radius law along `e`, the B-spline with the radius as its x and its own+/// parameter as its y (control points at the Greville abscissae), reversed when `start` is+/// nearer the end of the edge's interval than its start. `None` where the capi's is null.+fn law_along(k: &Kernel, b: &Brep, e: EdgeId, start: [f64; 3], degree: usize, knots: &[f64], radii: &[f64]) -> solidcore::Result<Option<FilletLaw>> {+ let edge = b.edge(e)?;+ let Some(curve) = edge.curve.as_ref() else { return Ok(None) };+ let ivl = edge.interval;+ let (Some(lo), Some(hi)) = (answer(curve.evaluate_point(k, ivl.min()))?, answer(curve.evaluate_point(k, ivl.max()))?) else {+ return Ok(None);+ };+ let at = p3(start);+ let reverse = (hi - at).length() < (lo - at).length();+ let (nk, nr) = (knots.len(), radii.len());+ let kv: Vec<f64> = (0..nk).map(|i| if reverse { 1.0 - knots[nk - 1 - i] } else { knots[i] }).collect();+ let mut cps = Vec::with_capacity(nr);+ for i in 0..nr {+ let g: f64 = (1..=degree).filter_map(|j| kv.get(i + j)).sum();+ let r = if reverse { radii[nr - 1 - i] } else { radii[i] };+ cps.push(Vec3::new(r, g / degree as f64, 0.0));+ }+ let (mut unique, mut mults): (Vec<f64>, Vec<usize>) = (Vec::new(), Vec::new());+ for &x in &kv {+ match (unique.last(), mults.last_mut()) {+ (Some(&u), Some(m)) if u == x => *m += 1,+ _ => {+ unique.push(x);+ mults.push(1);+ }+ }+ }+ let data = CanonicalData {+ dim: 3,+ degree,+ control_points: &cps,+ form: BSplineCurveForm::Unspecified,+ knot_multiplicities: &mults,+ knots: &unique,+ knot_type: KnotType::Unspecified,+ weights: None,+ trim: None,+ };+ let Some(c) = answer(BSplineCurve::create_canonical(&data))? else { return Ok(None) };+ // The law's map is the whole curve, 0 to 1 (`FilletLaw::new`'s).+ Ok(Some(FilletLaw::new(FilletLawKind::BSpline { law_curve: c, extended_law: None })))+}++/// `smlib_fillet_variable`: the one edge nearest `point` rounded with the radius law of+/// `degree`, `knots` and `radii`, 0 at the end nearest `start`.+pub(crate) fn fillet_variable(+ body: &Body,+ point: [f64; 3],+ tolerance: f64,+ start: [f64; 3],+ degree: usize,+ knots: &[f64],+ radii: &[f64],+) -> Result<Body> {+ if !points_ok(&[point], false) || !start.iter().all(|x| x.is_finite()) || !tolerance_ok(tolerance) || !law_ok(degree, knots, radii) {+ return Err(Error::Argument);+ }+ if law_pinches(degree, knots, radii) {+ return Err(Error::Unsupported);+ }+ on_copy("smlib_fillet_variable", body, |k, mut w| {+ let picked = match pick_edges(k, &w, &[point], tolerance)? {+ Ok((p, _)) => p,+ Err(m) => return Ok(Err(edge_miss(m))),+ };+ let [e] = picked[..] else { return Ok(Err(Error::NoMatch { point: 0 })) };+ let Some(law) = law_along(k, &w, e, start, degree, knots, radii)? else {+ return Ok(Err(Error::Status(INVALID_INPUT)));+ };+ // A law with a corner splits the round's face there (`SplitFilletFacesAtRadiusCorners`,+ // fork 6eecf04), which solidcore does not have.+ if law_has_corner(degree, knots, radii) {+ return Ok(Err(Error::Unsupported));+ }+ // The round is the union of its balls (smlib#78, solidcore#2262 with+ // `fillet_gn_section_generator`): each ball touches it along the circle shifted+ // -r r'/|c'| from its great circle. A law whose balls fold over one another is refused+ // (`NoRoomReason::BallsFold`), [`Error::NoRoom`].+ let solid_in = brep_p2::is_manifold_solid(&w)?;+ let (r0, r1) = (radii.first().copied().unwrap_or(0.0), radii.last().copied().unwrap_or(0.0));+ Ok(match blend_edges(k, &mut w, &[e], &[r0.max(r1)], Section::Round, Some(law), &[], None)? {+ Ok(()) => finish(w, solid_in)?,+ Err(Ok(_)) => Err(Error::Unsupported),+ Err(Err(e)) => Err(e),+ })+ })+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn laws_are_checked_as_the_capi_checks_them() {+ assert!(law_ok(1, &[0.0, 0.0, 1.0, 1.0], &[1.0, 2.0]));+ assert!(!law_ok(1, &[0.0, 0.0, 1.0], &[1.0, 2.0]));+ assert!(!law_ok(1, &[0.0, 0.5, 1.0, 1.0], &[1.0, 2.0]));+ assert!(!law_ok(1, &[0.0, 0.0, 1.0, 1.0], &[-1.0, 2.0]));+ assert!(!law_ok(4, &[0.0; 7], &[1.0, 2.0]));+ assert!(law_pinches(1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[1.0, 0.0, 1.0]));+ assert!(!law_pinches(1, &[0.0, 0.0, 1.0, 1.0], &[0.0, 1.0]));+ // A straight law has no corner; a bent one does at its inner knot; a cubic none.+ assert!(!law_has_corner(1, &[0.0, 0.0, 1.0, 1.0], &[1.0, 2.0]));+ assert!(!law_has_corner(1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[1.0, 1.5, 2.0]));+ assert!(law_has_corner(1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[1.0, 2.0, 1.0]));+ assert!(!law_has_corner(3, &[0.0, 0.0, 0.0, 0.0, 0.5, 1.0, 1.0, 1.0, 1.0], &[1.0, 2.0, 1.0, 2.0, 1.0]));+ }++ #[test]+ fn picks_follow_the_capis_rule() {+ let all = [0.0f64, 1.0, 3.0];+ let d = |x: f64, p: Point3| Ok(Some((x - p.x).abs()));+ assert_eq!(pick(&all, &[[0.9, 0.0, 0.0]], 0.5, 1e-6, d).unwrap(), Ok((vec![1.0], vec![0])));+ assert_eq!(pick(&all, &[[2.0, 0.0, 0.0]], 0.5, 1e-6, d).unwrap(), Err(Miss::None(0)));+ assert_eq!(pick(&all, &[[1.0, 0.0, 0.0], [0.5, 0.0, 0.0]], 1.0, 1e-6, d).unwrap(), Err(Miss::Ambiguous(1)));+ // The same entity twice is picked once, by its first point.+ assert_eq!(pick(&all, &[[3.1, 0.0, 0.0], [2.9, 0.0, 0.0]], 0.5, 1e-6, d).unwrap(), Ok((vec![3.0], vec![0])));+ }+}diff --git a/crates/smlib/src/core/blend_tests.rs b/crates/smlib/src/core/blend_tests.rsnew file mode 100644index 0000000000..e03e1e2312--- /dev/null+++ b/crates/smlib/src/core/blend_tests.rs@@ -0,0 +1,1051 @@+//! Fillets and chamfers on solidcore, against closed forms: every result exports to a record that+//! validates. With SMLib built, the same case on the C++ kernel gives the same volume, counts and+//! faces by surface kind, or the same error (parity only: the expected values are the analytic+//! ones).+//!+//! The bodies are solidcore's own boxes and cylinders.++use std::collections::BTreeMap;+use std::f64::consts::PI;+use std::sync::mpsc;+use std::time::Duration;++use super::blend::{Corners, blend, blend_dropping, blend_holes, chamfer_sides, fillet_variable};+use super::boolean::boolean;+use super::{Body, counts, make_box, make_cylinder, to_arrays, volume};+use crate::export::native;+use crate::{Blend, BooleanOp, ChamferSecond, Error};++/// A case longer than this is a hang.+const TIMEOUT: Duration = Duration::from_secs(300);++/// How near a pick point must be.+const TOL: f64 = 0.01;++#[derive(Clone, Copy, Debug)]+enum Shape {+ Box([f64; 3], [f64; 3]),+ Cylinder([f64; 3], f64, f64),+ /// A box (corner, size) less a cylinder along z (base centre, radius, height).+ Holed([f64; 3], [f64; 3], [f64; 3], f64, f64),+}++impl Shape {+ fn core(self) -> Body {+ match self {+ Shape::Box(o, s) => make_box(o, s),+ Shape::Cylinder(o, r, h) => make_cylinder(o, r, h),+ Shape::Holed(o, s, c, r, h) => {+ boolean(&make_box(o, s).unwrap(), &make_cylinder(c, r, h).unwrap(), BooleanOp::Subtract).map(|b| b.unwrap())+ }+ }+ .unwrap()+ }+}++#[derive(Clone, Debug)]+enum Op {+ /// `Brep::blend` of one kind, one size for every edge.+ Blend(Shape, Blend, Vec<[f64; 3]>, f64),+ /// `Brep::chamfer_sides`.+ Sides(Shape, Vec<[f64; 3]>, f64, ChamferSecond, [f64; 3]),+ /// `Brep::blend_setback` of rounds: edges, radius, corners, setbacks.+ Setback(Shape, Vec<[f64; 3]>, f64, Vec<[f64; 3]>, Vec<f64>),+ /// `Brep::fillet_variable`: edge point, start, degree, knots, radii.+ Variable(Shape, [f64; 3], [f64; 3], usize, Vec<f64>, Vec<f64>),+}++/// What a case must give.+#[derive(Clone, Debug)]+enum Expect {+ /// A body of this volume (relative 1e-9).+ Volume(f64),+ /// A body of this volume to this relative accuracy.+ Near(f64, f64),+ /// A body whose volume lies strictly between these.+ Between(f64, f64),+ /// This error.+ Fails(Error),+}++struct Case {+ op: Op,+ expect: Expect,+}++/// A 30 x 20 x 10 block from the origin.+const BLOCK: Shape = Shape::Box([0.0; 3], [30.0, 20.0, 10.0]);+const ABC: f64 = 6000.0;+/// Its top front edge, along x at y = 0, z = 10, 30 long.+const TOP_FRONT: [f64; 3] = [15.0, 0.0, 10.0];++/// The cross-section a round of radius r takes from a right-angled edge: (1 - π/4) r².+fn spandrel(r: f64) -> f64 {+ (1.0 - PI / 4.0) * r * r+}++fn case(name: &str) -> Case {+ let c = |op, expect| Case { op, expect };+ let r = 2.0;+ match name {+ // abc - (1 - π/4) r² L.+ "fillet_one_edge" => c(Op::Blend(BLOCK, Blend::Round, vec![TOP_FRONT], r), Expect::Volume(ABC - spandrel(r) * 30.0)),+ // Every edge rounded at r, the corners spheres: (a-2r)(b-2r)(c-2r) + 2r Σ(faces less+ // 2r) + πr² Σ(edges less 2r) + 4/3 πr³.+ "fillet_all_edges" => {+ let (a, b, h) = (30.0 - 2.0 * r, 20.0 - 2.0 * r, 10.0 - 2.0 * r);+ let v = a * b * h + 2.0 * r * (a * b + b * h + h * a) + PI * r * r * (a + b + h) + 4.0 / 3.0 * PI * r * r * r;+ let mut edges = Vec::new();+ for (y, z) in [(0.0, 0.0), (20.0, 0.0), (0.0, 10.0), (20.0, 10.0)] {+ edges.push([15.0, y, z]);+ }+ for (x, z) in [(0.0, 0.0), (30.0, 0.0), (0.0, 10.0), (30.0, 10.0)] {+ edges.push([x, 10.0, z]);+ }+ for (x, y) in [(0.0, 0.0), (30.0, 0.0), (0.0, 20.0), (30.0, 20.0)] {+ edges.push([x, y, 5.0]);+ }+ c(Op::Blend(BLOCK, Blend::Round, edges, r), Expect::Volume(v))+ }+ // The curvature section's default thumbweight is equal area (fork 6148773): on the+ // round's rails it takes off what the ball's circle does, abc - (1 - π/4) r² L.+ "fillet_curvature_one_edge" => {+ c(Op::Blend(BLOCK, Blend::Curvature, vec![TOP_FRONT], r), Expect::Volume(ABC - (1.0 - PI / 4.0) * r * r * 30.0))+ }+ // abc - d² L / 2.+ "chamfer_one_edge" => c(Op::Blend(BLOCK, Blend::Chamfer, vec![TOP_FRONT], r), Expect::Volume(ABC - r * r * 30.0 / 2.0)),+ // abc - d1 d2 L / 2: 2 back along the top (the face leaning most along +z), 3 down the+ // front.+ "chamfer_two_distances" => {+ c(Op::Sides(BLOCK, vec![TOP_FRONT], 2.0, ChamferSecond::Distance(3.0), [0.0, 0.0, 1.0]), Expect::Volume(ABC - 2.0 * 3.0 * 30.0 / 2.0))+ }+ // 2 back along the top, at 30° to it: d tan 30° down the front.+ "chamfer_distance_angle" => c(+ Op::Sides(BLOCK, vec![TOP_FRONT], 2.0, ChamferSecond::Angle(PI / 6.0), [0.0, 0.0, 1.0]),+ Expect::Volume(ABC - 2.0 * 2.0 * (PI / 6.0).tan() * 30.0 / 2.0),+ ),+ // A 5 mm cylinder 10 high, its top rim rounded at 1. Pappus: the spandrel (1 - π/4) r²,+ // its centroid (10 - 3π)/(12 - 3π) r in from the rim, swept round the axis.+ "fillet_cylinder_rim" => {+ let (big, h, r) = (5.0, 10.0, 1.0);+ let inset = (10.0 - 3.0 * PI) / (12.0 - 3.0 * PI) * r;+ c(+ Op::Blend(Shape::Cylinder([0.0; 3], big, h), Blend::Round, vec![[0.0, big, h]], r),+ Expect::Volume(PI * big * big * h - 2.0 * PI * (big - inset) * spandrel(r)),+ )+ }+ // The three edges at the corner (30, 20, 10) rounded at r, the corner set back 4 along+ // each. Without a setback the corner is a sphere's octant, and the block keeps+ // abc - (1 - π/4) r² Σ(L - r) - (1 - π/6) r³; the setback changes only what lies within+ // s + r of the corner, a cube of side s + r.+ "setback_corner" => {+ let s = 4.0;+ let plain = ABC - spandrel(r) * (30.0 + 20.0 + 10.0 - 3.0 * r) - (1.0 - PI / 6.0) * r * r * r;+ let near = (s + r) * (s + r) * (s + r);+ c(+ Op::Setback(BLOCK, vec![[15.0, 20.0, 10.0], [30.0, 10.0, 10.0], [30.0, 20.0, 5.0]], r, vec![[30.0, 20.0, 10.0]], vec![s]),+ Expect::Between(plain - near, plain + near),+ )+ }+ // The top front edge rounded from 1 at x = 0 to 3 at x = 30, linearly, each section+ // square to the edge a quarter circle: abc - (1 - π/4) ∫ r(x)² dx+ // = abc - (1 - π/4) L (r0² + r0 r1 + r1²) / 3. The round is a B-spline surface fitted to+ // those sections, which both kernels build 2.5e-7 short of it (and within 1e-9 of each+ // other), within the solver's fitting tolerance.+ // The union of the balls, r from 1 to 3 along the 30 mm edge: in each plane across the+ // edge, the area between the corner and where each ray from it first enters a ball+ // (Gauss-Legendre in the ray's angle, Simpson along the edge, converged to 1e-8 of the+ // body), 27.857434; the balls' great circles would take (1 - π/4) L (r0² + r0 r1 + r1²) / 3,+ // 27.898239.+ "fillet_variable_linear" => {+ c(Op::Variable(BLOCK, TOP_FRONT, [0.0, 0.0, 10.0], 1, vec![0.0, 0.0, 1.0, 1.0], vec![1.0, 3.0]), Expect::Near(ABC - 27.857434, 1e-6))+ }+ // A round of 12 on a 10 mm cube's top front edge is larger than either face beside it:+ // the fork builds it over the cliffs, on the faces' continuations, and cuts away all of+ // the cube outside the round's cylinder (axis y = 12, z = -2, radius 12). What stays is+ // 10 times the square's part inside that circle, ∫ (√(144 - u²) - 2) du over+ // u = y - 12 from -√140 to -2: 72 (asin(√140/12) - asin(1/6)) - 2 (√140 - 2).+ "fillet_over_a_cliff" => {+ let w = 140f64.sqrt();+ let area = 72.0 * ((w / 12.0).asin() - (1.0f64 / 6.0).asin()) - 2.0 * (w - 2.0);+ c(Op::Blend(Shape::Box([0.0; 3], [10.0; 3]), Blend::Round, vec![[5.0, 0.0, 10.0]], 12.0), Expect::Volume(10.0 * area))+ }+ // A round of 6 on the top rim of a cylinder of radius 5 is wider than the cylinder.+ "fillet_too_large" => {+ c(Op::Blend(Shape::Cylinder([0.0; 3], 5.0, 10.0), Blend::Round, vec![[0.0, 5.0, 10.0]], 6.0), Expect::Fails(Error::NoRoom))+ }+ "pick_near_nothing" => {+ c(Op::Blend(BLOCK, Blend::Round, vec![TOP_FRONT, [100.0, 100.0, 100.0]], r), Expect::Fails(Error::NoMatch { point: 1 }))+ }+ // A 20 mm cube with a hole of radius 5 along z whose wall touches the face y = 0 along+ // x = 10 (#1390): a 3 mm chamfer of the hole's top rim runs out of that face where the+ // rim meets it tangentially, a vertex no blend corner handles. The tangent chain the app+ // blends is picked: the rim at 135° and 315° round the hole (away from the cylinder's+ // seam at 0° and the face at 270°), and the two pieces of the top's front edge, which the+ // rim runs on tangentially into at (10, 0, 20).+ "chamfer_hole_rim_touching_a_face" => {+ let d = 5.0 * std::f64::consts::FRAC_1_SQRT_2;+ c(+ Op::Blend(+ Shape::Holed([0.0; 3], [20.0; 3], [10.0, 5.0, -1.0], 5.0, 22.0),+ Blend::Chamfer,+ vec![[10.0 - d, 5.0 + d, 20.0], [10.0 + d, 5.0 - d, 20.0], [5.0, 0.0, 20.0], [15.0, 0.0, 20.0]],+ 3.0,+ ),+ Expect::Fails(Error::CornerUnsupported),+ )+ }+ // √3 from all three edges at the corner (0, 0, 10).+ "pick_ambiguous" => c(Op::Blend(BLOCK, Blend::Round, vec![[-1.0, -1.0, 11.0]], r), Expect::Fails(Error::Ambiguous { point: 0 })),+ _ => panic!("{name}"),+ }+}++/// The tolerance a case picks with: the ambiguous point lies √3 from its edges.+fn tolerance(name: &str) -> f64 {+ if name == "pick_ambiguous" { 5.0 } else { TOL }+}++fn rel(a: f64, b: f64) -> f64 {+ (a - b).abs() / b.abs()+}++#[derive(Debug, PartialEq)]+struct Measured {+ volume: f64,+ counts: [usize; 3],+ kinds: BTreeMap<String, usize>,+}++fn kinds(rec: &solidcraft_geom::brep::Brep) -> BTreeMap<String, usize> {+ let mut out = BTreeMap::new();+ for f in &rec.faces {+ let v = serde_json::to_value(&f.surface).unwrap();+ *out.entry(v["kind"].as_str().unwrap_or("?").to_owned()).or_default() += 1;+ }+ out+}++fn on_core(name: &str, c: &Case) -> crate::Result<Body> {+ let tol = tolerance(name);+ match &c.op {+ Op::Blend(s, kind, points, size) => blend(&s.core(), *kind, points, &[*size], tol, &[], &[], Corners::Filled),+ Op::Sides(s, points, d, second, first) => chamfer_sides(&s.core(), points, tol, *d, *second, *first),+ Op::Setback(s, points, size, corners, setbacks) => {+ blend(&s.core(), Blend::Round, points, &vec![*size; points.len()], tol, corners, setbacks, Corners::Filled)+ }+ Op::Variable(s, point, start, degree, knots, radii) => fillet_variable(&s.core(), *point, tol, *start, *degree, knots, radii),+ }+}++/// Runs `f` on its own thread: a hang fails the test instead of stopping the run.+fn timed<T: Send + 'static>(name: &str, f: impl FnOnce() -> T + Send + 'static) -> T {+ let (tx, rx) = mpsc::channel();+ let worker = std::thread::spawn(move || {+ let _ = tx.send(f());+ });+ match rx.recv_timeout(TIMEOUT) {+ Ok(v) => v,+ Err(mpsc::RecvTimeoutError::Disconnected) => match worker.join() {+ Err(p) => std::panic::resume_unwind(p),+ Ok(()) => panic!("{name}: no result"),+ },+ Err(mpsc::RecvTimeoutError::Timeout) => panic!("{name}: solidcore hung (no result after {TIMEOUT:?})"),+ }+}++type Got = std::result::Result<Measured, Error>;++/// Checks a kernel's result against the case's closed form; what it measured, or its error.+fn judge(name: &str, who: &str, expect: &Expect, got: Got) -> Got {+ match (expect, &got) {+ (Expect::Fails(e), Err(g)) => assert_eq!(g, e, "{name}: {who} failed otherwise"),+ (Expect::Fails(e), Ok(m)) => panic!("{name}: {who} gave {m:?}, expected {e:?}"),+ (_, Err(g)) => panic!("{name}: {who} failed: {g}"),+ (Expect::Volume(v), Ok(m)) => assert!(rel(m.volume, *v) < 1e-9, "{name}: {who} volume {} vs analytic {v}", m.volume),+ (Expect::Near(v, within), Ok(m)) => assert!(rel(m.volume, *v) < *within, "{name}: {who} volume {} vs analytic {v}", m.volume),+ (Expect::Between(lo, hi), Ok(m)) => assert!(*lo < m.volume && m.volume < *hi, "{name}: {who} volume {} not in ({lo}, {hi})", m.volume),+ }+ got+}++fn solidcore_case(name: &'static str) -> Got {+ timed(name, move || {+ let c = case(name);+ let got = on_core(name, &c).map(|body| {+ let v = volume(&body, 1e-8).unwrap_or_else(|e| panic!("{name}: volume: {e}"));+ let n = counts(&body).unwrap();+ let (rec, _) = native(&to_arrays(&body).unwrap()).unwrap_or_else(|e| panic!("{name}: record: {e:?}"));+ rec.validate().unwrap_or_else(|e| panic!("{name}: record: {e}"));+ Measured { volume: v, counts: n, kinds: kinds(&rec) }+ });+ judge(name, "solidcore", &c.expect, got)+ })+}++/// The case on the C++ kernel, called directly (whatever the choice).+#[cfg(feature = "native")]+fn cpp_case(name: &str) -> Got {+ use crate::ops::{pick_error, setback_error};+ use crate::{Brep, ffi};+ crate::init().unwrap();+ let make = |s: Shape| -> Brep {+ match s {+ Shape::Box(o, z) => ffi::make_box(&o, &z),+ Shape::Cylinder(o, r, h) => ffi::make_cylinder(&o, r, h),+ Shape::Holed(o, z, c, r, h) => {+ ffi::ops::boolean(&ffi::make_box(&o, &z).unwrap(), &ffi::make_cylinder(&c, r, h).unwrap(), ffi::ops::BOOLEAN_SUBTRACT)+ }+ }+ .map(Brep::made)+ .unwrap()+ };+ let kind = |k| match k {+ Blend::Round => ffi::ops::BLEND_ROUND,+ Blend::Curvature => ffi::ops::BLEND_CURVATURE,+ Blend::Chord => ffi::ops::BLEND_CHORD,+ Blend::Chamfer => ffi::ops::BLEND_CHAMFER,+ };+ let c = case(name);+ let tol = tolerance(name);+ let r = match &c.op {+ Op::Blend(s, k, points, size) => {+ ffi::ops::blend(kind(*k), make(*s).cpp().unwrap(), points, &vec![*size; points.len()], tol).map_err(pick_error)+ }+ Op::Sides(s, points, d, second, first) => {+ let (value, angle) = match second {+ ChamferSecond::Distance(d) => (*d, false),+ ChamferSecond::Angle(a) => (*a, true),+ };+ ffi::ops::chamfer_sides(make(*s).cpp().unwrap(), points, tol, *d, value, angle, first).map_err(pick_error)+ }+ Op::Setback(s, points, size, corners, setbacks) => {+ ffi::ops::blend_setback(ffi::ops::BLEND_ROUND, make(*s).cpp().unwrap(), points, &vec![*size; points.len()], corners, setbacks, tol)+ .map_err(setback_error)+ }+ Op::Variable(s, point, start, degree, knots, radii) => {+ ffi::ops::fillet_variable(make(*s).cpp().unwrap(), point, tol, start, i32::try_from(*degree).unwrap(), knots, radii).map_err(+ |s| match s {+ ffi::ops::ERR_PICK_NONE => Error::NoMatch { point: 0 },+ ffi::ops::ERR_PICK_AMBIGUOUS => Error::Ambiguous { point: 0 },+ s => crate::error(s),+ },+ )+ }+ };+ let got = r.map(|h| {+ let v = ffi::volume(&h, 1e-8).unwrap();+ let n = ffi::counts(&h).unwrap().map(|x| usize::try_from(x).unwrap());+ let b = Brep::made(h);+ let (rec, _) = native(&b.cpp_arrays().unwrap()).unwrap();+ rec.validate().unwrap();+ Measured { volume: v, counts: n, kinds: kinds(&rec) }+ });+ judge(name, "C++", &c.expect, got)+}++/// solidcore and C++ agree: volume within 1e-9, the same counts and faces by kind, or the same+/// error.+#[cfg(feature = "native")]+fn parity(name: &'static str) {+ let cpp = cpp_case(name);+ let ours = solidcore_case(name);+ match (ours, cpp) {+ (Ok(a), Ok(b)) => {+ assert!(rel(a.volume, b.volume) < 1e-9, "{name}: solidcore {} vs C++ {}", a.volume, b.volume);+ assert_eq!(a.counts, b.counts, "{name}: face, edge, vertex counts (solidcore vs C++)");+ assert_eq!(a.kinds, b.kinds, "{name}: faces by surface kind (solidcore vs C++)");+ }+ (a, b) => assert_eq!(a.err(), b.err(), "{name}: errors (solidcore vs C++)"),+ }+}++macro_rules! cases {+ ($($m:ident $(: $ign:meta)?),* $(,)?) => {$(+ mod $m {+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_closed_form() {+ let _ = super::solidcore_case(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ super::parity(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ fn the_cpp_kernel_matches_the_closed_form() {+ let _cpp = crate::route::on_cpp();+ let _ = super::cpp_case(stringify!($m));+ }+ }+ )*};+}++cases!(+ fillet_one_edge,+ fillet_all_edges,+ fillet_curvature_one_edge,+ chamfer_one_edge,+ chamfer_two_distances,+ chamfer_distance_angle,+ fillet_cylinder_rim,+ setback_corner,+ fillet_variable_linear,+ fillet_over_a_cliff,+ fillet_too_large,+ chamfer_hole_rim_touching_a_face,+ pick_near_nothing,+ pick_ambiguous,+);++/// What solidcore does not have yet is refused as not supported, after the capi's own checks.+#[test]+fn fork_only_blends_are_not_supported_yet() {+ let r = timed("unsupported", || {+ let b = BLOCK.core();+ // 1 to 2 and back to 1: a corner at the middle.+ let bent = fillet_variable(&b, TOP_FRONT, TOL, [0.0, 0.0, 10.0], 1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[1.0, 2.0, 1.0]).err();+ // A pick that fails still says so first.+ let far = chamfer_sides(&b, &[[100.0; 3]], TOL, 2.0, ChamferSecond::Distance(3.0), [0.0, 0.0, 1.0]).err();+ (bent, far)+ });+ assert_eq!(r.0, Some(Error::Unsupported));+ assert_eq!(r.1, Some(Error::NoMatch { point: 0 }));+}++/// A cliff overflow the fork refuses too (`fixes.fillet_cliff_overflow`, solidcore#960): the+/// three edges at a 20 mm cube's corner rounded r20, their fillet's boundary on two faces'+/// surfaces, has no room, as on the fork, not "not supported".+#[test]+fn a_cliff_overflow_the_fork_refuses_has_no_room() {+ let r = timed("cliff_refused", || {+ let corner = [[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], [0.0, 0.0, 10.0]];+ blend(&Shape::Box([0.0; 3], [20.0; 3]).core(), Blend::Round, &corner, &[20.0; 3], TOL, &[], &[], Corners::Filled).err()+ });+ assert_eq!(r, Some(Error::NoRoom));+}++/// The capi's `overflow_goes_first` (fork 241f7ba): R21 on a 20 cube's edge takes all of both faces+/// that edge lies on, and rounds with it on other edges go after it. With R5 on the corner's other+/// two edges those edges are gone (the two R5 points flagged) and the result is the R21's alone,+/// 20 (F(w) - F(1) - (w - 1)) with F the integral of sqrt(441 - u²) and w = sqrt(440). With R5 on+/// the back upright that upright's round runs above the R21 cylinder, taking the corner's piece+/// over it too (Simpson on 4000 spans, against a bound of its quartic end edge's tolerance).+#[test]+fn overflow_goes_first() {+ #[cfg(feature = "native")]+ let _cpp = crate::route::on_cpp();+ let f = |u: f64| 0.5 * (u * (441.0 - u * u).sqrt() + 441.0 * (u / 21.0).asin());+ let w = 440f64.sqrt();+ let alone = 20.0 * (f(w) - f(1.0) - (w - 1.0));+ let strip = |t: f64| {+ let y = 15.0 + 5.0 * t.sin();+ let zc = 21.0 - (441.0 - (y - 21.0) * (y - 21.0)).sqrt();+ 5.0 * (1.0 - t.cos()) * (20.0 - zc) * 5.0 * t.cos()+ };+ let (n, h) = (4000, 0.5 * PI / 4000.0);+ let mut sum = strip(0.0) + strip(0.5 * PI);+ for i in 1..n {+ sum += f64::from(if i % 2 == 1 { 4 } else { 2 }) * strip(f64::from(i) * h);+ }+ let corner = sum * h / 3.0;+ assert!((corner - 106.612_300_588).abs() < 1e-6, "{corner}");+ let cases: [(&[[f64; 3]], &[f64], &[bool], f64, f64); 2] = [+ (&[[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], [0.0, 0.0, 10.0]], &[21.0, 5.0, 5.0], &[false, true, true], alone, 1e-9 * alone),+ (&[[10.0, 0.0, 0.0], [0.0, 20.0, 10.0]], &[21.0, 5.0], &[false, false], alone - corner, 0.02),+ ];+ for (points, sizes, dropped, want, bound) in cases {+ let got = timed("overflow_first", move || {+ let (b, d) = blend_dropping(&Shape::Box([0.0; 3], [20.0; 3]).core(), Blend::Round, points, sizes, 1.0).unwrap();+ native(&to_arrays(&b).unwrap()).unwrap();+ (volume(&b, 1e-8).unwrap(), d)+ });+ println!("overflow first {sizes:?}: {:.9}, expected {want:.9}", got.0);+ assert_eq!(got.1, dropped, "{sizes:?}");+ assert!((got.0 - want).abs() <= bound, "{sizes:?}: {} vs {want}", got.0);+ #[cfg(feature = "native")]+ {+ let body = crate::Brep::made_core(Shape::Box([0.0; 3], [20.0; 3]).core());+ let (cpp, d) = crate::ffi::ops::blend_dropping(crate::ffi::ops::BLEND_ROUND, body.cpp().unwrap(), points, sizes, 1.0).unwrap();+ assert_eq!(d, dropped, "C++ {sizes:?}");+ let v = crate::ffi::volume(&cpp, 1e-8).unwrap();+ assert!((got.0 - v).abs() <= bound, "{sizes:?}: solidcore {} vs C++ {v}", got.0);+ }+ }+}++/// The capi's `rounds_at_a_concave_face_corner_are_mitred` (`fixes.fillet_mitre_concave_face_corners`,+/// fork 4f06e72): each edge loses (convex) or gains (concave) the spandrel r²(1 - π/4) along its+/// length, and in the quadrant beyond both walls the mitred rounds take or add r³(5/3 - π/2): a+/// 60 x 40 x 10 plate's 30 x 20 x 5 pocket rim at r2 (15 faces) and r5 (11), a 60 x 60 x 5 plate's+/// 20 x 20 x 15 boss root at r4 (15). And the pocket rim chamfered 5.5, past the pocket's depth:+/// 21000 - (50 d² + 4/3 d³).+#[test]+fn rounds_at_a_concave_face_corner_are_mitred() {+ let made = |a: Body, b: Body, op| boolean(&a, &b, op).unwrap().unwrap();+ let pocket =+ || made(make_box([0.0; 3], [60.0, 40.0, 10.0]).unwrap(), make_box([15.0, 10.0, 5.0], [30.0, 20.0, 6.0]).unwrap(), BooleanOp::Subtract);+ let boss = || made(make_box([0.0; 3], [60.0, 60.0, 5.0]).unwrap(), make_box([20.0, 20.0, 5.0], [20.0, 20.0, 15.0]).unwrap(), BooleanOp::Union);+ let rim = [[30.0, 10.0, 10.0], [30.0, 30.0, 10.0], [15.0, 20.0, 10.0], [45.0, 20.0, 10.0]];+ let root = [[30.0, 20.0, 5.0], [40.0, 30.0, 5.0], [30.0, 40.0, 5.0], [20.0, 30.0, 5.0]];+ let want = |v0: f64, length: f64, r: f64, sign: f64| v0 + sign * (length * r * r * (1.0 - PI / 4.0) + 4.0 * r * r * r * (5.0 / 3.0 - PI / 2.0));+ for (body, edges, r, v, faces) in [+ (pocket(), rim, 2.0, want(21000.0, 100.0, 2.0, -1.0), 15),+ (pocket(), rim, 5.0, want(21000.0, 100.0, 5.0, -1.0), 11),+ (boss(), root, 4.0, want(24000.0, 80.0, 4.0, 1.0), 15),+ ] {+ let b = blend(&body, Blend::Round, &edges, &[r], 0.1, &[], &[], Corners::Filled).unwrap();+ native(&to_arrays(&b).unwrap()).unwrap();+ let got = volume(&b, 1e-12).unwrap();+ println!("mitred r{r}: {} faces, {got:.9}, expected {v:.9}", counts(&b).unwrap()[0]);+ assert_eq!(counts(&b).unwrap()[0], faces, "r{r}");+ assert!(rel(got, v) < 2e-8, "r{r}: {got} vs {v}");+ }+ // Through the flat arrays, as bodies reach a blend in the app (pocket_chamfer_on_a_boolean_body).+ let d = 5.5;+ let flat = super::from_arrays(&to_arrays(&pocket()).unwrap()).unwrap();+ let b = blend(&flat, Blend::Chamfer, &rim, &[d], 0.1, &[], &[], Corners::Filled).unwrap();+ let (got, v) = (volume(&b, 1e-8).unwrap(), 21000.0 - (50.0 * d * d + 4.0 / 3.0 * d * d * d));+ println!("mitred chamfer {d}: {got:.9}, expected {v:.9}");+ assert!(rel(got, v) < 1e-8, "{got} vs {v}");+}++/// Solidcore alone: edge attributes across a cliff overflow. A 40 x 30 x 10 block notched below its+/// top at (40, 0), its front and right top edges rounded r8 (their rails run off over the notch).+/// The back and left top edges are each trimmed 8 by those rounds: (0, 30)-(32, 30) and (0, 8)-(0, 30)+/// at z = 10, and each piece keeps its edge's attribute (`Behavior::Copy`), as on the fork.+#[test]+fn an_edge_tag_crosses_a_cliff_overflow() {+ use solidcore::blend::fillet_executive::session::FilletSession;+ use solidcore::boolean::api_brep::boolean_difference;+ use solidcore::geom::attribute::{Attribute, Behavior};+ use solidcore::primitive::api_primitives::create_box;+ use solidcore::topology::{Brep, EdgeId, edge, vertex};+ use solidcore::{EntityRef, Kernel, Point3};+ fn between(b: &Brep, a: Point3, q: Point3) -> Option<EdgeId> {+ b.edges().ids().find(|&e| {+ let (s, t) = edge::start_end_vertices(b, e).unwrap();+ let (s, t) = (vertex::point(b, s.unwrap()).unwrap(), vertex::point(b, t.unwrap()).unwrap());+ (s.distance(a) < 1e-6 && t.distance(q) < 1e-6) || (s.distance(q) < 1e-6 && t.distance(a) < 1e-6)+ })+ }+ let p = Point3::new;+ let mut k = Kernel::default();+ k.fixes.fillet_refuse_rails_leaving_faces = true;+ k.fixes.fillet_trace_reaches_rails = true;+ k.fixes.fillet_rail_end_on_continued_surface = true;+ k.fixes.fillet_cliff_overflow = true;+ let block = create_box(&mut k, Point3::ZERO, 40.0, 30.0, 10.0).unwrap();+ let notch = create_box(&mut k, p(35.0, -1.0, -1.0), 6.0, 6.0, 4.0).unwrap();+ let mut b = boolean_difference(&mut k, block, notch).unwrap();+ const ID: u64 = 0x7000_0001;+ let edge_at = |b: &Brep, a, q| between(b, a, q).unwrap();+ for (a, q, v) in [(p(0.0, 30.0, 10.0), p(40.0, 30.0, 10.0), 1), (p(0.0, 0.0, 10.0), p(0.0, 30.0, 10.0), 2)] {+ let e = edge_at(&b, a, q);+ b.add_attribute(EntityRef::Edge(e), Attribute::long(ID, v, Behavior::Copy)).unwrap();+ }+ let rounds = [edge_at(&b, p(0.0, 0.0, 10.0), p(40.0, 0.0, 10.0)), edge_at(&b, p(40.0, 0.0, 10.0), p(40.0, 30.0, 10.0))];+ let mut s = FilletSession::new(&mut k, &mut b).unwrap();+ s.prepare_constant_radius_edges(&mut k, &rounds, 8.0, 1, 1, 1.0).unwrap();+ s.do_fillet(&mut k).unwrap();+ drop(s);+ b.refresh_cached_topology();+ for (a, q, which) in [(p(0.0, 30.0, 10.0), p(32.0, 30.0, 10.0), "back"), (p(0.0, 8.0, 10.0), p(0.0, 30.0, 10.0), "left")] {+ let e = edge_at(&b, a, q);+ assert!(b.entity_attributes(EntityRef::Edge(e)).iter().any(|(_, x)| x.attribute_id() == ID), "the {which} edge lost its attribute");+ }+}++/// Solidcore alone: the pocket rim chamfered 5.5, as `fillet_mitre_concave_face_corners`' own test+/// does it, with `keep_operand_uv_trims` on too, on the body the boolean gives:+/// 21000 - (50 d² + 4/3 d³) = 19265.666666667 (the fork, and the same body through the flat+/// arrays). Without `fillet_run_on_bspline_trims` it is refused: error 3, Corner Edge Computation+/// Failure (solidcore#1981).+#[test]+fn pocket_chamfer_on_a_boolean_body() {+ use solidcore::blend::fillet_executive::session::FilletSession;+ use solidcore::boolean::api_brep::boolean_difference;+ use solidcore::primitive::api_primitives::create_box;+ use solidcore::topology::{EdgeId, edge, vertex};+ use solidcore::{Kernel, Point3};+ let p = Point3::new;+ let mut k = Kernel::default();+ k.fixes.fillet_refuse_rails_leaving_faces = true;+ k.fixes.fillet_trace_reaches_rails = true;+ k.fixes.fillet_rail_end_on_continued_surface = true;+ k.fixes.fillet_cliff_overflow = true;+ k.fixes.fillet_mitre_concave_face_corners = true;+ k.fixes.keep_operand_uv_trims = true;+ k.fixes.fillet_run_on_bspline_trims = true;+ let plate = create_box(&mut k, Point3::ZERO, 60.0, 40.0, 10.0).unwrap();+ let cut = create_box(&mut k, p(15.0, 10.0, 5.0), 30.0, 20.0, 6.0).unwrap();+ let mut b = boolean_difference(&mut k, plate, cut).unwrap();+ let c = [p(15.0, 10.0, 10.0), p(45.0, 10.0, 10.0), p(45.0, 30.0, 10.0), p(15.0, 30.0, 10.0)];+ let on = |x: Point3, a: Point3, q: Point3| x.distance(a) < 1e-9 || x.distance(q) < 1e-9;+ let ids: Vec<EdgeId> = (0..4)+ .map(|i| {+ let (a, q) = (c[i], c[(i + 1) % 4]);+ b.edges()+ .ids()+ .find(|&e| {+ let (s, t) = edge::start_end_vertices(&b, e).unwrap();+ on(vertex::point(&b, s.unwrap()).unwrap(), a, q) && on(vertex::point(&b, t.unwrap()).unwrap(), a, q) && s != t+ })+ .unwrap()+ })+ .collect();+ let mut s = FilletSession::new(&mut k, &mut b).unwrap();+ s.prepare_constant_radius_edges(&mut k, &ids, 5.5, 0, 1, 1.0).unwrap();+ let r = s.do_fillet(&mut k);+ assert!(r.is_ok(), "{} {}", s.error_info().code, s.error_info().comment);+ drop(s);+ b.refresh_cached_topology();+ let v = volume(&Body::new(b), 1e-8).unwrap();+ let d: f64 = 5.5;+ assert!(rel(v, 21000.0 - (50.0 * d * d + 4.0 / 3.0 * d * d * d)) < 1e-8, "{v}");+}++/// The corner of r5 rounds at (60, 40, 20) on a 60 x 40 x 20 box, set back 8 and left open: the+/// box's six faces and the three rounds (9 faces, 30 edges, 22 vertices), a sheet, and one hole+/// of twelve edges (each section and face curve in two), chained end to start, each beside a face+/// of the sheet. With SMLib built, the C++ kernel gives the same counts and the same hole.+#[test]+fn a_setback_corner_left_open_returns_its_hole() {+ #[cfg(feature = "native")]+ let _cpp = crate::route::on_cpp();+ let edges = [[30.0, 40.0, 20.0], [60.0, 20.0, 20.0], [60.0, 40.0, 10.0]];+ let (open, holes) = timed("setback_open", move || {+ let b = Shape::Box([0.0; 3], [60.0, 40.0, 20.0]).core();+ blend_holes(&b, Blend::Round, &edges, &[5.0; 3], 0.1, &[[60.0, 40.0, 20.0]], &[8.0], Corners::Open).unwrap()+ });+ assert_eq!(counts(&open).unwrap(), [9, 30, 22]);+ assert!(!super::is_manifold_solid(&open).unwrap());+ let [hole] = holes.as_slice() else { panic!("one corner: {holes:?}") };+ assert_eq!(hole.edges.len(), 12);+ let flat = to_arrays(&open).unwrap();+ let (rec, _) = native(&flat).unwrap();+ rec.validate().unwrap();+ let ends = &flat.ints[&crate::flat::EDGE_VERTICES];+ let end = |h: &crate::HoleEdge, last: bool| ends[2 * h.edge + usize::from(h.forward == last)];+ for (k, h) in hole.edges.iter().enumerate() {+ let next = &hole.edges[(k + 1) % 12];+ assert_eq!(end(h, true), end(next, false), "edge {k} ends where the next starts");+ assert!(h.face < 9);+ }+ #[cfg(feature = "native")]+ {+ crate::init().unwrap();+ let b = crate::ffi::make_box(&[0.0; 3], &[60.0, 40.0, 20.0]).map(crate::Brep::made).unwrap();+ let (h, values) = crate::ffi::ops::blend_setback_open(+ crate::ffi::ops::BLEND_ROUND,+ b.cpp().unwrap(),+ &edges,+ &[5.0; 3],+ &[[60.0, 40.0, 20.0]],+ &[8.0],+ 0.1,+ )+ .unwrap();+ assert_eq!(crate::ffi::counts(&h).unwrap(), [9, 30, 22], "C++ counts");+ let ours: Vec<i64> =+ std::iter::once(12).chain(hole.edges.iter().flat_map(|h| [h.edge as i64, h.face as i64, i64::from(h.forward)])).collect();+ assert_eq!(values, ours, "the hole (C++ vs solidcore)");+ }+ // A corner where an edge is not rounded builds no setback, and the refusal names it.+ let refused = timed("setback_open_refused", move || {+ let b = Shape::Box([0.0; 3], [60.0, 40.0, 20.0]).core();+ blend_holes(&b, Blend::Round, &edges[..2], &[5.0; 2], 0.1, &[[60.0, 40.0, 20.0]], &[8.0], Corners::Open).err()+ });+ assert_eq!(refused, Some(Error::CornerRefused { corner: 0 }));+}++/// A curvature-continuous round at the equal-area thumbweight takes off what the ball's circle+/// does, r² (cot(α/2) - (π - α)/2) per unit length on a wedge α (solidcore#2261): on a 40 x 30 x 20+/// box with its top back edge chamfered 5, r 2 along the chamfer's top edge (α 135°) takes+/// 0.0860579227 per mm, along the bottom front edge (α 90°) 0.8584073464. Both in one call are+/// refused: every edge takes the first one's thumbweight, so the other would take 17% too little+/// or 21% too much (solidcore#2250's comment 6563419897), whichever order they come in.+#[test]+fn a_curvature_round_takes_its_wedges_equal_area_and_mixed_wedges_are_refused() {+ let r = 2.0;+ let cut = |alpha: f64| r * r * (1.0 / (alpha / 2.0).tan() - (PI - alpha) / 2.0);+ let chamfered =+ blend(&Shape::Box([0.0; 3], [40.0, 30.0, 20.0]).core(), Blend::Chamfer, &[[20.0, 30.0, 20.0]], &[5.0], TOL, &[], &[], Corners::Filled)+ .unwrap();+ let v0 = volume(&chamfered, 1e-8).unwrap();+ assert!(rel(v0, 23500.0) < 1e-9, "{v0}");+ let (a, b) = ([20.0, 25.0, 20.0], [20.0, 0.0, 0.0]);+ for (at, alpha) in [(a, 0.75 * PI), (b, 0.5 * PI)] {+ let round = blend(&chamfered, Blend::Curvature, &[at], &[r], TOL, &[], &[], Corners::Filled).unwrap();+ let (rec, _) = native(&to_arrays(&round).unwrap()).unwrap();+ rec.validate().unwrap();+ let removed = v0 - volume(&round, 1e-8).unwrap();+ assert!(rel(removed, 40.0 * cut(alpha)) < 1e-6, "{removed} vs {}", 40.0 * cut(alpha));+ }+ for both in [[a, b], [b, a]] {+ let refused = blend(&chamfered, Blend::Curvature, &both, &[r], TOL, &[], &[], Corners::Filled).err();+ assert_eq!(refused, Some(Error::Unported(super::blend::CURVATURE_MIXED_WEDGES)));+ assert!(refused.is_some_and(|e| e.to_string().contains("issuecomment-6563419897")));+ }+ // Edges of one wedge go together.+ let two = blend(&chamfered, Blend::Curvature, &[b, [20.0, 0.0, 20.0]], &[r], TOL, &[], &[], Corners::Filled).unwrap();+ assert!(rel(v0 - volume(&two, 1e-8).unwrap(), 80.0 * cut(0.5 * PI)) < 1e-6);+ // A pick that misses is still named first.+ assert_eq!(blend(&chamfered, Blend::Curvature, &[[90.0; 3]], &[r], TOL, &[], &[], Corners::Filled).err(), Some(Error::NoMatch { point: 0 }));+}++/// A variable round is the union of its balls (solidcore#2262, `fillet_gn_section_generator`).+/// Along the 30 mm top front edge: a law of one radius 2 takes the constant round's+/// (1 - π/4) 4 · 30 = 25.752220; 1 to 3, the balls' union's 27.857434 (the great circles would take+/// 27.898239), either way along the edge. Both come out 5.3e-5 of that over, as on the C+++/// kernel: the solver's surface fit. A law whose radius climbs faster than a rolling ball can+/// follow (1 to 4 within a mm) folds its balls over one another: refused, not built.+#[test]+fn a_variable_round_is_the_union_of_its_balls() {+ let b = BLOCK.core();+ let removed = |radii: &[f64], start: [f64; 3]| {+ let r = fillet_variable(&b, TOP_FRONT, TOL, start, 1, &[0.0, 0.0, 1.0, 1.0], radii).unwrap();+ let (rec, _) = native(&to_arrays(&r).unwrap()).unwrap();+ rec.validate().unwrap();+ ABC - volume(&r, 1e-8).unwrap()+ };+ let constant = removed(&[2.0, 2.0], [0.0, 0.0, 10.0]);+ assert!(rel(constant, (1.0 - PI / 4.0) * 4.0 * 30.0) < 1e-4, "{constant}");+ let linear = removed(&[1.0, 3.0], [0.0, 0.0, 10.0]);+ assert!(rel(linear, 27.857434) < 1e-4, "{linear}");+ assert!(rel(removed(&[1.0, 3.0], [30.0, 0.0, 10.0]), linear) < 1e-8);+ let steep = [0.0, 0.0, 0.0, 0.0, 0.02, 0.04, 1.0, 1.0, 1.0, 1.0];+ let folds = fillet_variable(&b, TOP_FRONT, TOL, [0.0, 0.0, 10.0], 3, &steep, &[1.0, 1.0, 4.0, 4.0, 4.0, 4.0]).err();+ assert_eq!(folds, Some(Error::NoRoom));+ // A pick that misses is still named first.+ assert_eq!(fillet_variable(&b, [90.0; 3], TOL, [0.0; 3], 1, &[0.0, 0.0, 1.0, 1.0], &[1.0, 3.0]).err(), Some(Error::NoMatch { point: 0 }));+}++/// The capi's argument checks, before any kernel call.+#[test]+fn hostile_arguments_are_refused() {+ let b = BLOCK.core();+ let none = Corners::Filled;+ assert_eq!(blend(&b, Blend::Round, &[], &[1.0], TOL, &[], &[], none).err(), Some(Error::Argument));+ assert_eq!(blend(&b, Blend::Round, &[[f64::NAN; 3]], &[1.0], TOL, &[], &[], none).err(), Some(Error::Argument));+ assert_eq!(blend(&b, Blend::Round, &[TOP_FRONT], &[-1.0], TOL, &[], &[], none).err(), Some(Error::Argument));+ assert_eq!(blend(&b, Blend::Round, &[TOP_FRONT], &[1.0], 0.0, &[], &[], none).err(), Some(Error::Argument));+ assert_eq!(blend(&b, Blend::Round, &[TOP_FRONT], &[f64::INFINITY], TOL, &[], &[], none).err(), Some(Error::Argument));+ // A chamfer's corners are bevelled, which builds no setback.+ assert_eq!(blend(&b, Blend::Chamfer, &[TOP_FRONT], &[1.0], TOL, &[[0.0, 0.0, 10.0]], &[1.0], none).err(), Some(Error::Unsupported));+ assert_eq!(fillet_variable(&b, TOP_FRONT, TOL, [0.0; 3], 1, &[0.0, 1.0], &[1.0, 2.0]).err(), Some(Error::Argument));+ // A radius that pinches to nothing inside the edge.+ assert_eq!(fillet_variable(&b, TOP_FRONT, TOL, [0.0; 3], 1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[1.0, 0.0, 1.0]).err(), Some(Error::Unsupported));+ assert_eq!(chamfer_sides(&b, &[TOP_FRONT], TOL, 1.0, ChamferSecond::Angle(4.0), [0.0, 0.0, 1.0]).err(), Some(Error::Argument));+ assert_eq!(chamfer_sides(&b, &[TOP_FRONT], TOL, 1.0, ChamferSecond::Distance(1.0), [0.0; 3]).err(), Some(Error::Argument));+}++/// A setback longer than an edge at its corner leaves no room, before any blend is made.+#[test]+fn a_setback_past_an_edge_has_no_room() {+ let r = timed("setback_long", || {+ let b = BLOCK.core();+ let corner = [[15.0, 20.0, 10.0], [30.0, 10.0, 10.0], [30.0, 20.0, 5.0]];+ blend(&b, Blend::Round, &corner, &[2.0; 3], TOL, &[[30.0, 20.0, 10.0]], &[10.0], Corners::Filled).err()+ });+ assert_eq!(r, Some(Error::NoRoom));+}++/// The body blended is never changed.+#[test]+fn the_body_stays_as_it_was() {+ let r = timed("operand", || {+ let b = BLOCK.core();+ let _ = blend(&b, Blend::Round, &[TOP_FRONT], &[2.0], TOL, &[], &[], Corners::Filled);+ (counts(&b).unwrap(), volume(&b, 1e-8).unwrap())+ });+ assert_eq!(r.0, [6, 12, 8]);+ assert!(rel(r.1, ABC) < 1e-12, "{}", r.1);+}++/// The chamfer's first distance goes on the face leaning most along `first`: 2 along the top and+/// 3 down the front for +z, the other way round for -y. The volumes are the same; the centroid+/// tells them apart. The removed prism's section is the triangle with legs t (back along the+/// top, in y) and f (down the front, in z) at the edge (y = 0, z = 10), centroid+/// (t/3, 10 - f/3), area t f / 2: the block keeps ȳ = (6000·10 - 15 t f · t/3) / (6000 - 15 t f)+/// and z̄ = (6000·5 - 15 t f (10 - f/3)) / (6000 - 15 t f).+#[test]+fn the_first_distance_goes_on_the_face_along_first() {+ for (first, top, front) in [([0.0, 0.0, 1.0], 2.0, 3.0), ([0.0, -1.0, 0.0], 3.0, 2.0)] {+ let r = timed("sides_first", move || {+ let b = BLOCK.core();+ chamfer_sides(&b, &[TOP_FRONT], TOL, 2.0, ChamferSecond::Distance(3.0), first).and_then(|c| super::mass_properties(&c, 1e-8))+ });+ let m = r.unwrap_or_else(|e| panic!("{first:?}: {e}"));+ let cut = 15.0 * top * front;+ let y = (6000.0 * 10.0 - cut * top / 3.0) / (6000.0 - cut);+ let z = (6000.0 * 5.0 - cut * (10.0 - front / 3.0)) / (6000.0 - cut);+ assert!(rel(m.volume, 6000.0 - cut) < 1e-9, "{first:?}: volume {}", m.volume);+ assert!((m.centroid[1] - y).abs() < 1e-7 && (m.centroid[2] - z).abs() < 1e-7, "{first:?}: centroid {:?} vs ({y}, {z})", m.centroid);+ }+}++/// Face and edge tags (`Brep::tagged`) through blends on solidcore, as on C++: the box is+/// tagged on the C++ kernel, its solidcore body converted from that and tagged the same way, and+/// the two results' histories must be the same.+#[cfg(feature = "native")]+mod history {+ use solidcraft_geom::brep::history::Change;++ use crate::history::Raw;+ use crate::{Blend, Brep, ffi};++ /// A 20 x 30 x 10 box, tagged as operand 0, with `kind` of `size` on its top front edge+ /// (y = 0, z = 10), on both kernels: solidcore's history, then the C++ kernel's.+ fn one_edge(kind: Blend, size: f64) -> (Raw, Raw) {+ crate::init().unwrap();+ let a = Brep::made(ffi::make_box(&[0.0; 3], &[20.0, 30.0, 10.0]).unwrap()).tagged(0).unwrap();+ let edge = [[10.0, 0.0, 10.0]];+ let code = match kind {+ Blend::Round => ffi::ops::BLEND_ROUND,+ Blend::Curvature => ffi::ops::BLEND_CURVATURE,+ Blend::Chord => ffi::ops::BLEND_CHORD,+ Blend::Chamfer => ffi::ops::BLEND_CHAMFER,+ };+ let cpp = ffi::ops::blend(code, a.cpp().unwrap(), &edge, &[size], super::TOL).unwrap();+ let cpp = Brep::made(cpp).history().unwrap();+ let core = super::blend(a.core().unwrap(), kind, &edge, &[size], super::TOL, &[], &[], super::Corners::Filled).unwrap();+ (Brep::made_core(core).history().unwrap(), cpp)+ }++ /// The changes of `h`'s faces, sorted: one blend of one box edge leaves the bottom and back+ /// as they were, trims the top, front and both sides, and makes the blend face.+ fn changes(h: &Raw) -> Vec<Change> {+ let mut c: Vec<Change> = h.faces.iter().map(|f| f.change).collect();+ c.sort_by_key(|c| *c as u8);+ c+ }++ fn check(kind: Blend, size: f64) {+ let (core, cpp) = one_edge(kind, size);+ let want = [Change::Kept, Change::Kept, Change::Modified, Change::Modified, Change::Modified, Change::Modified, Change::Generated];+ assert_eq!(changes(&cpp), want, "C++ {kind:?}: {cpp:?}");+ assert_eq!(core.canonical(), cpp.canonical(), "{kind:?}");+ }++ /// A 2 mm round on the top front edge of a box: the top and front are trimmed, the round is+ /// new.+ #[test]+ fn tags_cross_a_fillet() {+ let _cpp = crate::route::on_cpp();+ check(Blend::Round, 2.0);+ }++ /// A 2 mm chamfer on the same edge: the same faces kept, trimmed and made as the round.+ #[test]+ fn tags_cross_a_chamfer() {+ let _cpp = crate::route::on_cpp();+ check(Blend::Chamfer, 2.0);+ }+}++/// The capi's `knife_edge_chamfers` (fork e96898d): a 10 high extrusion of the profile whose arc+/// of radius R = 21 runs out tangent into its top line at the tip x = 62 1/6 (a knife edge, a+/// cusp), chamfered d at the tip. No ball lies d back along both faces there; the chamfer is the+/// chord between the contacts of the ball of radius d, sqrt(4 R d) back on the flat face and where+/// the line from the arc's axis to the ball's centre meets the wall. It takes the triangle flat+/// contact, tip, wall contact less the wall's circular segment R²/2 (b - sin b),+/// b = acos((R - d)/(R + d)): at d = 2 the chord is 3.822 wide and takes 159.23645 (each to+/// 1e-12). Mirrored in x too.+#[test]+fn knife_edge_chamfers() {+ use super::sweep::extrude;+ use super::transform::transform;+ use crate::sweeps::{Curve, DraftCorner};++ const R: f64 = 21.0;+ const TIP: f64 = 62.0 + 1.0 / 6.0;+ const H: f64 = 10.0;+ let line = |a: [f64; 2], b: [f64; 2]| Curve::Line { start: [a[0], a[1], 0.0], end: [b[0], b[1], 0.0] };+ let profile = [+ line([0.0, 0.0], [0.0, -R]),+ line([0.0, -R], [TIP - R, -R]),+ Curve::Arc { center: [TIP, -R, 0.0], axis: [0.0, 0.0, -1.0], reference: [1.0, 0.0, 0.0], radius: R, start: PI, end: 1.5 * PI },+ line([TIP, 0.0], [0.0, 0.0]),+ ];+ let part = extrude(&profile, [0.0, 0.0, 1.0], H, 0.0, DraftCorner::Curvature, true).unwrap();+ let before = (TIP - R) * R * H + R * R * (1.0 - PI / 4.0) * H;+ assert!((volume(&part, 1e-8).unwrap() - before).abs() < 1e-9 * before);+ for d in [1.0, 2.0, 5.0] {+ let flat = TIP - (4.0 * R * d).sqrt();+ let (wx, wy) = (TIP - (4.0 * R * d).sqrt() * R / (R + d), -R + (R - d) * R / (R + d));+ let triangle = 0.5 * ((TIP - flat) * wy).abs();+ let b = ((R - d) / (R + d)).acos();+ let removed = (triangle - 0.5 * R * R * (b - b.sin())) * H;+ if d == 2.0 {+ assert!((removed - 159.236_450_742_901_18).abs() < 1e-12 * 159.24);+ assert!(((wx - flat).hypot(wy) - 3.822_132_343_623_634_7).abs() < 1e-12 * 3.83);+ }+ for mirrored in [false, true] {+ let sx = if mirrored { -1.0 } else { 1.0 };+ let m = [[sx, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]];+ let body = transform(&part, &m).unwrap();+ let tip = [sx * TIP, 0.0, H / 2.0];+ let cut = blend(&body, Blend::Chamfer, &[tip], &[d], TOL, &[], &[], Corners::Filled).unwrap();+ let v = volume(&cut, 1e-8).unwrap();+ let want = before - removed;+ assert!((v - want).abs() < 1e-9 * want, "d {d} mirrored {mirrored}: {v} vs {want}");+ native(&to_arrays(&cut).unwrap()).unwrap();+ }+ }+}++/// The part from SolidCraft #871: a plate with a narrower block on top and a window through both.+fn part_871() -> Body {+ let (a, b) = (12.74437365538526, 22.69275963366936);+ let at = |lo: [f64; 3], hi: [f64; 3]| make_box(lo, [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]]).unwrap();+ let joined = boolean(&at([9.5, 8.0, 0.0], [23.5, 29.5, 10.0]), &at([9.5, a, 10.0], [23.5, b, 20.0]), BooleanOp::Union).unwrap().unwrap();+ boolean(&joined, &at([9.5, 14.0, 7.0], [23.5, 19.2, 14.1]), BooleanOp::Subtract).unwrap().unwrap()+}++/// The 12 edges round each of the part's two end faces.+fn edges_871() -> Vec<[f64; 3]> {+ let yz = [+ (12.74437365538526, 15.0),+ (10.37218682769263, 10.0),+ (8.0, 5.0),+ (18.75, 0.0),+ (29.5, 5.0),+ (26.09637981683468, 10.0),+ (22.69275963366936, 15.0),+ (17.71856664452731, 20.0),+ (16.6, 7.0),+ (14.0, 10.55),+ (16.6, 14.100000000000001),+ (19.200000000000003, 10.55),+ ];+ [23.5, 9.5].iter().flat_map(|x| yz.iter().map(move |(y, z)| [*x, *y, *z])).collect()+}++/// #871's rounds at r 0.5 fit (the wall between the window and the block's side is 1.26 thick):+/// 38 faces, and the closed form `issue_871_tests::rounds_that_fit_are_closed` derives. At r 1 they+/// overlap, which is refused. With SMLib built, the C++ kernel gives the same.+#[cfg(feature = "native")]+#[test]+fn rounds_on_the_871_part() {+ let _cpp = crate::route::on_cpp();+ rounds_on_the_871_part_check();+}++/// The same on a build without the C++ kernel: solidcore's half alone. A test of its own, so that+/// tests/KNOWN_FAILING_TESTS's entry for the C++ comparison (rounds_on_the_871_part) is graded only where it runs.+#[cfg(not(feature = "native"))]+#[test]+fn rounds_on_the_871_part_on_solidcore() {+ rounds_on_the_871_part_check();+}++fn rounds_on_the_871_part_check() {+ let p = part_871();+ let e = edges_871();+ let sizes = |r: f64| vec![r; e.len()];+ let part_volume = 14.0 * (21.5 * 10.0 + (22.69275963366936 - 12.74437365538526) * 10.0 - 5.2 * 7.1);+ let exact = part_volume - 2.0 * (2.0 * (21.5 + 20.0) + 2.0 * (5.2 + 7.1)) * spandrel(0.5);+ let fit = blend(&p, Blend::Round, &e, &sizes(0.5), TOL, &[], &[], Corners::Filled).unwrap();+ let (v, n) = (volume(&fit, 1e-8).unwrap(), counts(&fit).unwrap());+ let refused = blend(&p, Blend::Round, &e, &sizes(1.0), TOL, &[], &[], Corners::Filled).map(|_| ()).unwrap_err();+ assert_eq!(refused, Error::NoRoom);+ assert_eq!(n[0], 38);+ assert!((v - exact).abs() < 1e-3, "{v} vs {exact}");+ #[cfg(feature = "native")]+ {+ use crate::{Brep, ffi};+ crate::init().unwrap();+ let bx = |lo: [f64; 3], hi: [f64; 3]| ffi::make_box(&lo, &[hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]]).unwrap();+ let top = ffi::ops::boolean(+ &bx([9.5, 8.0, 0.0], [23.5, 29.5, 10.0]),+ &bx([9.5, 12.74437365538526, 10.0], [23.5, 22.69275963366936, 20.0]),+ ffi::ops::BOOLEAN_UNION,+ )+ .unwrap();+ let cut = ffi::ops::boolean(&top, &bx([9.5, 14.0, 7.0], [23.5, 19.2, 14.1]), ffi::ops::BOOLEAN_SUBTRACT).unwrap();+ let cpp = Brep::made(cut);+ let h = cpp.cpp().unwrap();+ let fit = ffi::ops::blend(ffi::ops::BLEND_ROUND, h, &e, &sizes(0.5), TOL).unwrap();+ let (cv, cn) = (ffi::volume(&fit, 1e-8).unwrap(), ffi::counts(&fit).unwrap().map(|x| usize::try_from(x).unwrap()));+ let crefused = ffi::ops::blend(ffi::ops::BLEND_ROUND, h, &e, &sizes(1.0), TOL).map(|_| ());+ assert!(rel(v, cv) < 1e-9, "solidcore {v} vs C++ {cv}");+ assert_eq!(n, cn);+ assert!(crefused.is_err());+ }+}++/// The fork's `tabbed_plate_rounds_mitred_on_the_arcs_continuation`: a plate 2 thick, its outline an+/// R25 arc to the sides x = +-4 of a tab whose top is 4 wide with R2 corners, every top edge of the+/// outline rounded r 0.5. The arc's round and the tab side's are mitred on the arc wall's+/// continuation. Removed: the outline's area less the area of the outline moved in by+/// d = r (1 - cos phi), at the height r sin phi into the round (midpoint rule, 8192 steps; the area+/// by Green's theorem). With SMLib built, the C++ kernel gives the same.+#[test]+fn tabbed_plate_rounds_mitred_on_the_arcs_continuation() {+ #[cfg(feature = "native")]+ let _cpp = crate::route::on_cpp();+ use super::sweep::extrude;+ use crate::sweeps::{Curve, DraftCorner};+ const Z: [f64; 3] = [0.0, 0.0, 1.0];+ let theta = (4.0_f64 / 25.0).acos();+ let y = 609.0_f64.sqrt();+ let cy = 280.0 / 9.0;+ let line = |a: [f64; 2], b: [f64; 2]| Curve::Line { start: [a[0], a[1], 0.0], end: [b[0], b[1], 0.0] };+ let arc = |c: [f64; 2], radius, start, end| Curve::Arc { center: [c[0], c[1], 0.0], axis: Z, reference: [1.0, 0.0, 0.0], radius, start, end };+ let outline = [+ arc([0.0, 0.0], 25.0, PI - theta, 2.0 * PI + theta),+ line([4.0, y], [4.0, cy]),+ arc([2.0, cy], 2.0, 0.0, PI / 2.0),+ line([2.0, cy + 2.0], [-2.0, cy + 2.0]),+ arc([-2.0, cy], 2.0, PI / 2.0, PI),+ line([-4.0, cy], [-4.0, y]),+ ];+ let area = |da: f64, dt: f64| {+ let (big, rho) = (25.0 - da, 2.0 - dt);+ let tab = rho * rho * PI + 2.0 * rho * (2.0 + cy) + 4.0 * (cy + rho);+ let yc = (big * big - (4.0 - dt) * (4.0 - dt)).sqrt();+ let at = yc.atan2(4.0 - dt);+ 0.5 * (big * big * (PI + 2.0 * at) + tab) + (4.0 - dt) * (cy - yc)+ };+ let (r, dphi) = (0.5, (PI / 2.0) / 8192.0);+ let want: f64 = (0..8192)+ .map(|i| {+ let phi = (f64::from(i) + 0.5) * dphi;+ let d = r * (1.0 - phi.cos());+ (area(0.0, 0.0) - area(d, d)) * r * phi.cos() * dphi+ })+ .sum();+ let top = [+ [0.0, -25.0, 2.0],+ [4.0, 27.8945, 2.0],+ [3.41421356, 32.5253247, 2.0],+ [0.0, cy + 2.0, 2.0],+ [-3.41421356, 32.5253247, 2.0],+ [-4.0, 27.8945, 2.0],+ ];+ let plate = extrude(&outline, Z, 2.0, 0.0, DraftCorner::default(), true).unwrap();+ assert!(rel(volume(&plate, 1e-8).unwrap(), 2.0 * area(0.0, 0.0)) < 1e-10);+ let round = blend(&plate, Blend::Round, &top, &[r; 6], TOL, &[], &[], Corners::Filled).unwrap();+ let removed = volume(&plate, 1e-8).unwrap() - volume(&round, 1e-8).unwrap();+ assert!(rel(removed, want) < 1e-6, "removed {removed}, expected {want}");+ let (rec, _) = native(&to_arrays(&round).unwrap()).unwrap();+ rec.validate().unwrap();+ assert!(super::is_manifold_solid(&round).unwrap());+ assert!(super::check(&round, crate::check::CheckLevel::All).unwrap().is_valid());+ #[cfg(feature = "native")]+ {+ use crate::{Brep, ffi};+ crate::init().unwrap();+ let list = crate::sweeps::List::of(&outline).unwrap();+ let cpp = ffi::sweeps::extrude(&list.raw(), &Z, 2.0, 0.0, ffi::sweeps::DRAFT_CORNER_CURVATURE, true, &mut [f64::NAN; 3]).unwrap();+ let cround = ffi::ops::blend(ffi::ops::BLEND_ROUND, Brep::made(cpp).cpp().unwrap(), &top, &[r; 6], TOL).unwrap();+ let cv = ffi::volume(&cround, 1e-8).unwrap();+ assert!(rel(volume(&round, 1e-8).unwrap(), cv) < 1e-9);+ assert_eq!(counts(&round).unwrap(), ffi::counts(&cround).unwrap().map(|x| usize::try_from(x).unwrap()));+ }+}diff --git a/crates/smlib/src/core/boolean.rs b/crates/smlib/src/core/boolean.rsnew file mode 100644index 0000000000..2fac368df1--- /dev/null+++ b/crates/smlib/src/core/boolean.rs@@ -0,0 +1,243 @@+//! Booleans on solidcore: the C API's own logic round `SM_API`, ported from the fork's+//! `capi/src/smlib_ops.cpp` (`smlib_boolean_with`, `smlib_boolean2d`,+//! `smlib_boolean_union_all`, `finish`, `closed_nonmanifold`) and+//! `capi/src/smlib_imprint.cpp` (`smlib_imprint`).+//!+//! As there, every operation works on copies of its operands (`SmApiBrepCopy`): `SM_API` edits+//! the first operand in place and consumes the second, and a SolidCraft body never changes.++use std::sync::PoisonError;++use solidcore::Result as SolidResult;+use solidcore::SolidError;+use solidcore::boolean::api_brep::{self as sm, Boolean2dOutcome};+use solidcore::boolean::merge::MergeOptions;+use solidcore::geom::a_object::BooleanOperation;+use solidcore::kernel::Kernel;+use solidcore::primitive::primitive_creation::p1::Boolean2d;+use solidcore::topology::brep::p3::brep_copy;+use solidcore::topology::brep::{p1, p2};+use solidcore::topology::{Brep, edge};++use super::{Body, run};+use crate::{BooleanOp, Error, Result};++/// What an operation's `SM_API` call gave, before it is a SolidCraft result: the capi's+/// statuses besides success.+enum Done {+ Body(Box<Brep>),+ /// `SMLIB_ERR_EMPTY`.+ Empty,+ /// `SMLIB_ERR_NOT_SOLID`.+ NotSolid,+ /// `SMLIB_ERR_NO_CUT` (`smlib_imprint`).+ NoCut,+}++impl super::dump::Answer for Done {+ fn refusal(&self) -> Option<String> {+ matches!(self, Done::NotSolid).then(|| Error::NotSolid.to_string())+ }+}++/// `GetNumFaces`.+fn num_faces(b: &Brep) -> usize {+ b.face_list().len()+}++/// `closed_nonmanifold` (smlib_ops.cpp): a closed body whose solids touch only along edges or at+/// vertices: at least two regions, no shell vertices, no wire edge, and four edgeuses (two faces,+/// both sides) per face round every edge. As there, an edge whose query fails (`e == nullptr`, a+/// failed `GetEdgeuses`) makes it false: [`edge_closes`].+fn closed_nonmanifold(r: &Brep) -> SolidResult<bool> {+ if p1::regions(r, None)?.len() < 2 {+ return Ok(false);+ }+ if !p2::shell_vertices(r, None)?.is_empty() {+ return Ok(false);+ }+ for e in p1::edges(r, None)? {+ if !edge_closes(edge::is_wire(r, e), edge::edgeuses(r, e, None, None).map(|u| u.len())) {+ return Ok(false);+ }+ }+ Ok(true)+}++/// The capi's test of one edge in `closed_nonmanifold`, given its `IsWire` and the count of its+/// `GetEdgeuses`: not a wire, and four edgeuses per face round it. Either query failing is+/// false, not an error: the capi returns false where `GetEdgeuses` fails.+pub(super) fn edge_closes(wire: SolidResult<bool>, uses: SolidResult<usize>) -> bool {+ matches!(wire, Ok(false)) && matches!(uses, Ok(n) if n >= 4 && n % 4 == 0)+}++/// `finish` (smlib_ops.cpp): the result must have faces, and a solid input must give a closed+/// manifold solid or (`nonmanifold`) a closed one whose solids touch along an edge or at a vertex.+fn finish(r: Brep, solid_in: bool, nonmanifold: bool) -> SolidResult<Done> {+ if num_faces(&r) == 0 {+ return Ok(Done::Empty);+ }+ if solid_in && !p2::is_manifold_solid(&r)? && !(nonmanifold && closed_nonmanifold(&r)?) {+ return Ok(Done::NotSolid);+ }+ Ok(Done::Body(Box::new(r)))+}++/// What a failing call's dump calls its first operands.+const OPERANDS: [&str; 4] = ["a", "b", "c", "d"];++/// Copies of `bodies`, in order (a body given twice is copied twice, as the capi copies each+/// operand), all made under the kernel's lock.+fn copies(k: &mut Kernel, bodies: &[&Body]) -> SolidResult<Vec<Brep>> {+ // Under the kernel's lock (`run` holds it), as every body lock is: two never deadlock.+ let mut out = Vec::with_capacity(bodies.len());+ for (n, b) in bodies.iter().enumerate() {+ let g = b.0.lock().unwrap_or_else(PoisonError::into_inner);+ super::dump::input(k, OPERANDS.get(n).copied().unwrap_or("operand"), &g);+ let c = brep_copy(k, &g)?;+ drop(g);+ out.push(c);+ }+ Ok(out)+}++fn result(d: Done, empty: Result<Option<Body>>) -> Result<Option<Body>> {+ match d {+ Done::Body(b) => Ok(Some(Body::new(*b))),+ Done::Empty => empty,+ Done::NotSolid => Err(Error::NotSolid),+ Done::NoCut => Ok(None),+ }+}++fn operation(op: BooleanOp) -> BooleanOperation {+ match op {+ BooleanOp::Union => BooleanOperation::Union,+ BooleanOp::Subtract => BooleanOperation::Difference,+ BooleanOp::Intersect => BooleanOperation::Intersection,+ }+}++/// Whether every body is a manifold solid (`IsManifoldSolid` of each copy).+fn all_solid(bodies: &[Brep]) -> SolidResult<bool> {+ for b in bodies {+ if !p2::is_manifold_solid(b)? {+ return Ok(false);+ }+ }+ Ok(true)+}++/// Fails when a panic left one of `bodies` half-edited: it is never used again.+fn usable(call: &'static str, bodies: &[&Body]) -> Result<()> {+ if bodies.iter().any(|b| b.0.is_poisoned()) {+ return Err(Error::Internal(format!("{call}: the body was left unfinished by an earlier panic")));+ }+ Ok(())+}++/// `smlib_boolean` (`smlib_boolean_with` with `SMLIB_RESULT_NONMANIFOLD`): `SmApiBoolean` on+/// copies of `a` and `b`; `None` when the result is empty (`SMLIB_ERR_EMPTY`), and+/// [`Error::NotSolid`] when solid operands give a body that is not closed.+pub(crate) fn boolean(a: &Body, b: &Body, op: BooleanOp) -> Result<Option<Body>> {+ usable("SmApiBoolean", &[a, b])?;+ let d = run("SmApiBoolean", |k| {+ let mut c = copies(k, &[a, b])?.into_iter();+ let (Some(ca), Some(cb)) = (c.next(), c.next()) else {+ return Err(SolidError::invalid_input("smlib_boolean", "no operand"));+ };+ let solid_in = p2::is_manifold_solid(&ca)? && p2::is_manifold_solid(&cb)?;+ let r = sm::boolean(k, ca, cb, operation(op))?;+ finish(r.result, solid_in, true)+ })?;+ result(d, Ok(None))+}++/// `smlib_boolean_union_all`: copies of `bodies` unioned pairwise, level by level (an odd one+/// carried to the next level as it is), each union `SmApiBoolean`'s; then `finish` with+/// non-manifold results allowed. An empty result is [`Error::Empty`].+pub(crate) fn union_all(bodies: &[&Body]) -> Result<Body> {+ if bodies.is_empty() || bodies.len() > crate::MAX_UNION_BREPS {+ return Err(Error::Argument);+ }+ usable("smlib_boolean_union_all", bodies)?;+ let d = run("smlib_boolean_union_all", |k| {+ let mut level = copies(k, bodies)?;+ let solid_in = all_solid(&level)?;+ while level.len() > 1 {+ let mut next = Vec::with_capacity(level.len().div_ceil(2));+ let mut it = level.into_iter();+ while let Some(a) = it.next() {+ match it.next() {+ Some(b) => next.push(sm::boolean(k, a, b, BooleanOperation::Union)?.result),+ None => next.push(a),+ }+ }+ level = next;+ }+ match level.pop() {+ Some(r) => finish(r, solid_in, true),+ None => Ok(Done::Empty),+ }+ })?;+ result(d, Err(Error::Empty))?.ok_or(Error::Empty)+}++/// `smlib_boolean2d`: `SmApiBoolean2d` (`SmPrimitiveCreation::Boolean2D`) on copies of `a` and+/// `b`, sheets of planar faces on one plane; `None` when either has no face (where+/// `SmApiBoolean2d` succeeds without a result) or the result is empty.+pub(crate) fn boolean2d(a: &Body, b: &Body, op: BooleanOp) -> Result<Option<Body>> {+ usable("SmApiBoolean2d", &[a, b])?;+ let d = run("SmApiBoolean2d", |k| {+ let mut c = copies(k, &[a, b])?.into_iter();+ let (Some(ca), Some(cb)) = (c.next(), c.next()) else {+ return Err(SolidError::invalid_input("smlib_boolean2d", "no operand"));+ };+ if num_faces(&ca) == 0 || num_faces(&cb) == 0 {+ return Ok(Done::Empty);+ }+ let kind = match op {+ BooleanOp::Union => Boolean2d::Union,+ BooleanOp::Subtract => Boolean2d::Difference,+ BooleanOp::Intersect => Boolean2d::Intersection,+ };+ match sm::boolean_2d(k, ca, cb, kind)? {+ Boolean2dOutcome::Result(r) => finish(r, false, false),+ Boolean2dOutcome::Unassigned { .. } => Ok(Done::Empty),+ }+ })?;+ result(d, Ok(None))+}++/// `smlib_imprint`: `SmApiBooleanWithOptions(SM_BO_IMPRINT)` on copies of `body` and `tool`,+/// imprinting and keeping the tool (cookie cutter off, imprinting on, post-process off,+/// imprint-and-classify off, keep other on). `None` when no face was cut+/// (`SMLIB_ERR_NO_CUT`); an empty result is [`Error::Empty`]; the same body twice is+/// [`Error::Argument`].+pub(crate) fn imprint(body: &Body, tool: &Body) -> Result<Option<Body>> {+ if std::ptr::eq(body, tool) {+ return Err(Error::Argument);+ }+ usable("SmApiBooleanWithOptions", &[body, tool])?;+ let d = run("SmApiBooleanWithOptions", |k| {+ let mut c = copies(k, &[body, tool])?.into_iter();+ let (Some(a), Some(t)) = (c.next(), c.next()) else {+ return Err(SolidError::invalid_input("smlib_imprint", "no operand"));+ };+ let before = num_faces(&a);+ let options = MergeOptions::new(false, true, false, false, true);+ let r = sm::boolean_with_options(k, a, t, BooleanOperation::Imprint, options)?.result;+ let after = num_faces(&r);+ Ok(if after == 0 {+ Done::Empty+ } else if after == before {+ Done::NoCut+ } else {+ Done::Body(Box::new(r))+ })+ })?;+ match d {+ Done::Empty => Err(Error::Empty),+ d => result(d, Err(Error::Empty)),+ }+}diff --git a/crates/smlib/src/core/boolean_tests.rs b/crates/smlib/src/core/boolean_tests.rsnew file mode 100644index 0000000000..8b6606a158--- /dev/null+++ b/crates/smlib/src/core/boolean_tests.rs@@ -0,0 +1,728 @@+//! Booleans on solidcore, against analytic volumes: every result exports to a record that+//! validates and counts the solids it should. With SMLib built, the same case on the C++ kernel+//! gives the same volume, counts, faces by surface kind and solids (parity only: the expected+//! values are the analytic ones).+//!+//! Curved operands are built on solidcore itself.++use std::collections::BTreeMap;+use std::f64::consts::PI;+use std::sync::mpsc;+use std::time::Duration;++use solidcore::geom::axis2_placement::Axis2Placement;+use solidcore::geom::vector3d::Vec3;+use solidcore::mass::integrator::properties::brep_area;+use solidcore::primitive::primitive_creation::p1::create_rectangle;++use super::boolean::{boolean, boolean2d, edge_closes, imprint, union_all};+use super::{Body, counts, make_box, make_cylinder, make_sphere, run, solid_count, to_arrays, volume, with_body};+use crate::export::native;+use crate::{BooleanOp, Error};++/// A case longer than this is a hang.+const TIMEOUT: Duration = Duration::from_secs(300);++/// An operand.+#[derive(Clone, Copy, Debug)]+enum Shape {+ Box([f64; 3], [f64; 3]),+ Cylinder([f64; 3], f64, f64),+ Sphere([f64; 3], f64),+}++impl Shape {+ fn core(self) -> Body {+ match self {+ Shape::Box(o, s) => make_box(o, s),+ Shape::Cylinder(o, r, h) => make_cylinder(o, r, h),+ Shape::Sphere(c, r) => make_sphere(c, r),+ }+ .unwrap()+ }+}++/// What a case does.+#[derive(Clone, Debug)]+enum Op {+ Boolean(Shape, Shape, BooleanOp),+ UnionAll(Vec<Shape>),+ Imprint(Shape, Shape),+}++/// A case: the operation, its analytic volume (`None`: the result is empty), the faces it+/// must have where they are known analytically, and its solids (`smlib_brep_solid_count`).+struct Case {+ op: Op,+ volume: Option<f64>,+ faces: Option<usize>,+ solids: usize,+}++const A: Shape = Shape::Box([0.0; 3], [10.0; 3]);++fn case(name: &str) -> Case {+ let plain = |op, volume: Option<f64>, faces| Case { op, volume, faces, solids: 1 };+ match name {+ // |A| + |B| - |A ∩ B|: two 10 mm cubes overlapping in a 5 mm cube.+ "union_overlapping" => plain(Op::Boolean(A, Shape::Box([5.0; 3], [10.0; 3]), BooleanOp::Union), Some(1000.0 + 1000.0 - 125.0), Some(12)),+ // Two 10 mm cubes 10 mm apart: one body of two solids, 12 faces.+ "union_disjoint" => {+ Case { solids: 2, ..plain(Op::Boolean(A, Shape::Box([20.0, 0.0, 0.0], [10.0; 3]), BooleanOp::Union), Some(2000.0), Some(12)) }+ }+ "intersect_overlapping" => plain(Op::Boolean(A, Shape::Box([5.0; 3], [10.0; 3]), BooleanOp::Intersect), Some(125.0), Some(6)),+ // A slot 5 mm wide and 5 mm deep from the top, right through a 30 x 20 x 10 block.+ "subtract_through_slot" => plain(+ Op::Boolean(Shape::Box([0.0; 3], [30.0, 20.0, 10.0]), Shape::Box([10.0, -1.0, 5.0], [5.0, 22.0, 6.0]), BooleanOp::Subtract),+ Some(6000.0 - 5.0 * 20.0 * 5.0),+ Some(10),+ ),+ // A notch whose tool is flush with the block's front, back and top faces.+ "subtract_flush_notch" => plain(+ Op::Boolean(Shape::Box([0.0; 3], [30.0, 20.0, 10.0]), Shape::Box([10.0, 0.0, 5.0], [10.0, 20.0, 5.0]), BooleanOp::Subtract),+ Some(6000.0 - 10.0 * 20.0 * 5.0),+ Some(10),+ ),+ // A 4 mm cube inside a 10 mm one: a void, still one solid.+ "subtract_inside_void" => plain(Op::Boolean(A, Shape::Box([3.0; 3], [4.0; 3]), BooleanOp::Subtract), Some(1000.0 - 64.0), Some(12)),+ // abc - πr²c: a 3 mm hole through a 20 x 20 x 10 block.+ "subtract_cylinder_hole" => plain(+ Op::Boolean(Shape::Box([0.0; 3], [20.0, 20.0, 10.0]), Shape::Cylinder([10.0, 10.0, -1.0], 3.0, 12.0), BooleanOp::Subtract),+ Some(4000.0 - PI * 9.0 * 10.0),+ None,+ ),+ // Nine 10 mm cubes, each touching its neighbours face to face.+ "union_all_grid" => plain(+ Op::UnionAll((0..9).map(|i| Shape::Box([f64::from(i % 3) * 10.0, f64::from(i / 3) * 10.0, 0.0], [10.0; 3])).collect()),+ Some(9000.0),+ None,+ ),+ "intersect_disjoint" => plain(Op::Boolean(A, Shape::Box([20.0; 3], [10.0; 3]), BooleanOp::Intersect), None, None),+ // A 10 mm sphere less a cap of height h = 5: 4/3 πr³ - πh²(3r - h)/3.+ // (solidcore#1431, brep_volume of a whole sphere failing at 1e-8, does not touch the cut+ // sphere: it measures at 1e-8.)+ "sphere_minus_box" => plain(+ Op::Boolean(Shape::Sphere([0.0; 3], 10.0), Shape::Box([-20.0, -20.0, 5.0], [40.0, 40.0, 20.0]), BooleanOp::Subtract),+ Some(4.0 / 3.0 * PI * 1000.0 - PI * 25.0 * 25.0 / 3.0),+ Some(2),+ ),+ // A 4 mm square tool through the cube's top face: that face is cut in two (a square and+ // the ring round it), nothing else changes.+ "imprint_top_face" => plain(Op::Imprint(A, Shape::Box([3.0, 3.0, 8.0], [4.0; 3])), Some(1000.0), Some(7)),+ _ => panic!("{name}"),+ }+}++fn rel(a: f64, b: f64) -> f64 {+ (a - b).abs() / b.abs()+}++/// What a kernel's result measures.+#[derive(Debug, PartialEq)]+struct Measured {+ volume: f64,+ counts: [usize; 3],+ /// The record's faces by surface kind.+ kinds: BTreeMap<String, usize>,+ solids: usize,+}++fn kinds(rec: &solidcraft_geom::brep::Brep) -> BTreeMap<String, usize> {+ let mut out = BTreeMap::new();+ for f in &rec.faces {+ let v = serde_json::to_value(&f.surface).unwrap();+ *out.entry(v["kind"].as_str().unwrap_or("?").to_owned()).or_default() += 1;+ }+ out+}++/// The case on solidcore: `None` for an empty result.+fn on_core(c: &Case) -> crate::Result<Option<Body>> {+ match &c.op {+ Op::Boolean(a, b, op) => boolean(&a.core(), &b.core(), *op),+ Op::UnionAll(shapes) => {+ let bodies: Vec<Body> = shapes.iter().map(|s| s.core()).collect();+ union_all(&bodies.iter().collect::<Vec<_>>()).map(Some)+ }+ Op::Imprint(a, t) => imprint(&a.core(), &t.core()),+ }+}++/// Runs `f` on its own thread: a hang fails the test instead of stopping the run.+fn timed<T: Send + 'static>(name: &str, f: impl FnOnce() -> T + Send + 'static) -> T {+ let (tx, rx) = mpsc::channel();+ let worker = std::thread::spawn(move || {+ let _ = tx.send(f());+ });+ match rx.recv_timeout(TIMEOUT) {+ Ok(v) => v,+ // The case panicked: its own message is the failure.+ Err(mpsc::RecvTimeoutError::Disconnected) => match worker.join() {+ Err(p) => std::panic::resume_unwind(p),+ Ok(()) => panic!("{name}: no result"),+ },+ Err(mpsc::RecvTimeoutError::Timeout) => panic!("{name}: solidcore hung (no result after {TIMEOUT:?})"),+ }+}++/// Runs the case on solidcore and checks it against the analytic answer; what it measured.+fn solidcore_case(name: &'static str) -> Option<Measured> {+ timed(name, move || {+ let c = case(name);+ let r = on_core(&c).unwrap_or_else(|e| panic!("{name}: solidcore failed: {e}"));+ let (Some(body), Some(expected)) = (&r, c.volume) else {+ assert!(r.is_none() && c.volume.is_none(), "{name}: solidcore gave {}, expected {:?}", r.is_some(), c.volume);+ return None;+ };+ let v = volume(body, 1e-8).unwrap_or_else(|e| panic!("{name}: volume: {e}"));+ assert!(rel(v, expected) < 1e-9, "{name}: solidcore volume {v} vs analytic {expected}");+ let n = counts(body).unwrap();+ if let Some(f) = c.faces {+ assert_eq!(n[0], f, "{name}: faces {n:?}");+ }+ let solids = solid_count(body).unwrap_or_else(|e| panic!("{name}: solid count: {e}"));+ assert_eq!(solids, c.solids, "{name}: solids");+ let (rec, _) = native(&to_arrays(body).unwrap()).unwrap_or_else(|e| panic!("{name}: record: {e:?}"));+ rec.validate().unwrap_or_else(|e| panic!("{name}: record: {e}"));+ Some(Measured { volume: v, counts: n, kinds: kinds(&rec), solids })+ })+}++/// The case on the C++ kernel, called directly (whatever the choice): what it measured.+#[cfg(feature = "native")]+fn cpp_case(name: &str) -> Option<Measured> {+ use crate::{Brep, ffi};+ crate::init().unwrap();+ let make = |s: Shape| -> Brep {+ match s {+ Shape::Box(o, z) => ffi::make_box(&o, &z),+ Shape::Cylinder(o, r, h) => ffi::make_cylinder(&o, r, h),+ Shape::Sphere(c, r) => ffi::make_sphere(&c, r),+ }+ .map(Brep::made)+ .unwrap()+ };+ let bool_op = |op| match op {+ BooleanOp::Union => ffi::ops::BOOLEAN_UNION,+ BooleanOp::Subtract => ffi::ops::BOOLEAN_SUBTRACT,+ BooleanOp::Intersect => ffi::ops::BOOLEAN_INTERSECT,+ };+ let c = case(name);+ let r = match &c.op {+ Op::Boolean(a, b, op) => ffi::ops::boolean(make(*a).cpp().unwrap(), make(*b).cpp().unwrap(), bool_op(*op)),+ Op::UnionAll(shapes) => {+ let bodies: Vec<Brep> = shapes.iter().map(|s| make(*s)).collect();+ let handles: Vec<&ffi::Handle> = bodies.iter().map(|b| b.cpp().unwrap()).collect();+ ffi::ops::boolean_union_all(&handles)+ }+ Op::Imprint(a, t) => ffi::ops::imprint(make(*a).cpp().unwrap(), make(*t).cpp().unwrap()),+ };+ let h = match r {+ Ok(h) => h,+ Err(ffi::ERR_EMPTY) => return None,+ Err(s) => panic!("{name}: C++ failed: {:?}", crate::error(s)),+ };+ let v = ffi::volume(&h, 1e-8).unwrap();+ let n = ffi::counts(&h).unwrap().map(|x| usize::try_from(x).unwrap());+ let solids = usize::try_from(ffi::ops::solid_count(&h).unwrap()).unwrap();+ let b = Brep::made(h);+ let (rec, _) = native(&b.cpp_arrays().unwrap()).unwrap();+ rec.validate().unwrap();+ Some(Measured { volume: v, counts: n, kinds: kinds(&rec), solids })+}++/// solidcore and C++ agree: volume within 1e-9, the same counts and faces by kind.+#[cfg(feature = "native")]+fn parity(name: &'static str) {+ let ours = solidcore_case(name);+ let cpp = cpp_case(name);+ match (ours, cpp) {+ (None, None) => {}+ (Some(a), Some(b)) => {+ assert!(rel(a.volume, b.volume) < 1e-9, "{name}: solidcore {} vs C++ {}", a.volume, b.volume);+ assert_eq!(a.counts, b.counts, "{name}: face, edge, vertex counts (solidcore vs C++)");+ assert_eq!(a.kinds, b.kinds, "{name}: faces by surface kind (solidcore vs C++)");+ assert_eq!(a.solids, b.solids, "{name}: solids (solidcore vs C++)");+ }+ (a, b) => panic!("{name}: solidcore {a:?} vs C++ {b:?}"),+ }+}++macro_rules! cases {+ ($($m:ident $(: $ign:meta)?),* $(,)?) => {$(+ mod $m {+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_analytic_volume() {+ super::solidcore_case(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ super::parity(stringify!($m));+ }+ }+ )*};+}++cases!(+ union_overlapping,+ union_disjoint,+ intersect_overlapping,+ subtract_through_slot,+ subtract_flush_notch,+ subtract_inside_void,+ subtract_cylinder_hole,+ union_all_grid,+ intersect_disjoint,+ sphere_minus_box,+ imprint_top_face,+);++/// A `w` x `h` planar sheet on z = 0 from `(x, y)`, solidcore's `CreateRectangle`.+fn rectangle(x: f64, y: f64, w: f64, h: f64) -> Body {+ let frame = Axis2Placement::new(Vec3::new(x, y, 0.0), Vec3::new(1.0, 0.0, 0.0), Vec3::new(0.0, 1.0, 0.0));+ run("create_rectangle", |k| create_rectangle(k, 0.0, w, h, &frame)).map(Body::new).unwrap()+}++fn area(b: &Body) -> f64 {+ with_body("brep_area", b, |k, b| brep_area(k, b, 1e-8)).unwrap()+}++/// Two 10 mm squares overlapping in a 5 mm one, as regions of their plane.+#[test]+fn boolean2d_combines_overlapping_squares() {+ for (op, expected) in [(BooleanOp::Union, 175.0), (BooleanOp::Intersect, 25.0), (BooleanOp::Subtract, 75.0)] {+ let (a, b) = (rectangle(0.0, 0.0, 10.0, 10.0), rectangle(5.0, 5.0, 10.0, 10.0));+ let r = timed("boolean2d", move || boolean2d(&a, &b, op).map(|r| r.map(|r| (area(&r), counts(&r).unwrap()))));+ let (got, n) = r.unwrap_or_else(|e| panic!("{op:?}: {e}")).unwrap_or_else(|| panic!("{op:?}: empty"));+ assert!(rel(got, expected) < 1e-9, "{op:?}: area {got} vs {expected}");+ assert_eq!(n[0], 1, "{op:?}: {n:?}");+ }+ let (a, far) = (rectangle(0.0, 0.0, 10.0, 10.0), rectangle(20.0, 0.0, 10.0, 10.0));+ assert!(boolean2d(&a, &far, BooleanOp::Intersect).unwrap().is_none(), "disjoint squares intersected");+}++/// `closed_nonmanifold`'s test of an edge, as the capi's: an edge whose wire or edgeuse query+/// fails makes the body not closed non-manifold (false), never an error that fails the boolean.+#[test]+fn closed_nonmanifold_takes_a_failed_edge_query_as_false() {+ let failed = || solidcore::SolidError::null_pointer("GetEdgeuses");+ assert!(edge_closes(Ok(false), Ok(4)));+ assert!(edge_closes(Ok(false), Ok(8)));+ assert!(!edge_closes(Ok(false), Ok(2)));+ assert!(!edge_closes(Ok(false), Ok(6)));+ assert!(!edge_closes(Ok(true), Ok(4)));+ assert!(!edge_closes(Ok(false), Err(failed())));+ assert!(!edge_closes(Err(failed()), Ok(4)));+}++/// Two 10 mm cubes touching along one edge, joined: a closed body whose two solids meet along+/// that edge (four edgeuses round it), 2000 mm³.+#[test]+fn cubes_touching_along_an_edge_join_closed_nonmanifold() {+ let r = timed("edge_touching", || {+ let a = Shape::Box([0.0; 3], [10.0; 3]).core();+ let b = Shape::Box([10.0, 10.0, 0.0], [10.0; 3]).core();+ boolean(&a, &b, BooleanOp::Union).map(|r| r.map(|r| (volume(&r, 1e-8).unwrap(), solid_count(&r).unwrap())))+ });+ let (v, solids) = r.unwrap().unwrap();+ assert!(rel(v, 2000.0) < 1e-9, "volume {v}");+ assert_eq!(solids, 2);+}++/// The capi's argument checks: the same body imprinted on itself, an empty union.+#[test]+fn hostile_operands_are_refused() {+ let a = A.core();+ assert_eq!(imprint(&a, &a).err(), Some(Error::Argument));+ assert_eq!(union_all(&[]).err(), Some(Error::Argument));+}++/// A tool that meets no face cuts none.+#[test]+fn imprint_of_a_far_tool_is_none() {+ let r = timed("imprint_far", || imprint(&A.core(), &Shape::Box([20.0; 3], [1.0; 3]).core()).map(|r| r.is_none()));+ assert!(r.unwrap());+}++/// An operand is never changed: the same body twice, and again after.+#[test]+fn operands_stay_as_they_were() {+ let r = timed("operands", || {+ let a = A.core();+ let b = Shape::Box([5.0; 3], [10.0; 3]).core();+ let u = boolean(&a, &b, BooleanOp::Union).map(|r| r.is_some());+ let same = boolean(&a, &a, BooleanOp::Union).map(|r| r.map(|r| volume(&r, 1e-8)));+ (u, same, counts(&a).unwrap(), volume(&a, 1e-8).unwrap(), counts(&b).unwrap())+ });+ let (u, same, ca, va, cb) = r;+ assert!(u.unwrap());+ assert_eq!(ca, [6, 12, 8]);+ assert_eq!(cb, [6, 12, 8]);+ assert!(rel(va, 1000.0) < 1e-12, "{va}");+ let v = same.unwrap().unwrap().unwrap();+ assert!(rel(v, 1000.0) < 1e-9, "A ∪ A: {v}");+}++/// `moved`: a closest-point query that fails, even with an error that is no SMLib status (an edge+/// without its curve here), counts as off the piece, as `SmApiEdgeClosestPoint` failing does in the+/// capi (smlib_history.cpp:246): the face is Modified, the operation stands.+#[test]+fn a_failed_closest_point_counts_as_off_the_piece() {+ use solidcore::query::api_queries::edge_closest_point;+ use solidcore::topology::edge;+ let body = A.core();+ super::with_body("moved", &body, |k, b| {+ let e = b.edge_list()[0];+ let (Some(s), Some(f)) = edge::start_end_vertices(b, e)? else { panic!("an edge with no ends") };+ let (s, f) = (b.vertex(s)?.point, b.vertex(f)?.point);+ let at = [s, f, s + (f - s) * 0.5];+ let tol = b.tolerance();+ assert!(!super::history::moved(k, b, &[(e, &at)], tol)?, "still where it lay");+ b.edge_mut(e)?.curve = None;+ assert!(edge_closest_point(k, b, e, at[2]).is_err_and(|e| e.sm_status().is_none()), "fails with no status");+ assert!(super::history::moved(k, b, &[(e, &at)], tol)?, "off the piece");+ Ok(())+ })+ .unwrap();+}++/// Face and edge tags (`Brep::tagged`) through operations on solidcore, as on C++: each+/// operand is tagged on the C++ kernel, its solidcore body converted from that and tagged the same+/// way there, and the two results' histories ([`Raw`], each in its own kernel's face and edge+/// order) must be the same.+#[cfg(feature = "native")]+mod history {+ use crate::history::Raw;+ use crate::{BooleanOp, Brep, ffi};++ fn tagged_box(origin: [f64; 3], size: [f64; 3], operand: usize) -> Brep {+ crate::init().unwrap();+ Brep::made(ffi::make_box(&origin, &size).unwrap()).tagged(operand).unwrap()+ }++ /// Two 10 mm cubes overlapping in a 5 mm one (the capi's `overlapping_boxes_union`): 12+ /// faces, each from one face of one box, six from each.+ fn check(h: &Raw) {+ assert_eq!(h.faces.len(), 12, "{h:?}");+ assert!(h.faces.iter().all(|f| f.origins.len() == 1), "a face without exactly one origin: {h:?}");+ for operand in [0, 1] {+ assert_eq!(h.faces.iter().filter(|f| f.origins[0].0 == operand).count(), 6, "operand {operand}: {h:?}");+ }+ }++ #[test]+ fn tags_cross_a_cpp_boolean() {+ let _cpp = crate::route::on_cpp();+ let (a, b) = (tagged_box([0.0; 3], [10.0; 3], 0), tagged_box([5.0; 3], [10.0; 3], 1));+ let r = Brep::made(ffi::ops::boolean(a.cpp().unwrap(), b.cpp().unwrap(), ffi::ops::BOOLEAN_UNION).unwrap());+ check(&r.history().unwrap());+ }++ #[test]+ fn tags_cross_a_solidcore_boolean() {+ let _cpp = crate::route::on_cpp();+ let (a, b) = (tagged_box([0.0; 3], [10.0; 3], 0), tagged_box([5.0; 3], [10.0; 3], 1));+ let r = super::boolean(a.core().unwrap(), b.core().unwrap(), BooleanOp::Union).unwrap().unwrap();+ check(&Brep::made_core(r).history().unwrap());+ }++ /// `a` op `b` on both kernels: the same history.+ fn parity(a: &Brep, b: &Brep, op: BooleanOp) {+ let code = match op {+ BooleanOp::Union => ffi::ops::BOOLEAN_UNION,+ BooleanOp::Subtract => ffi::ops::BOOLEAN_SUBTRACT,+ BooleanOp::Intersect => ffi::ops::BOOLEAN_INTERSECT,+ };+ let cpp = Brep::made(ffi::ops::boolean(a.cpp().unwrap(), b.cpp().unwrap(), code).unwrap()).history().unwrap();+ let core = Brep::made_core(super::boolean(a.core().unwrap(), b.core().unwrap(), op).unwrap().unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ }++ #[test]+ fn an_overlapping_union_has_the_cpp_history() {+ let _cpp = crate::route::on_cpp();+ parity(&tagged_box([0.0; 3], [10.0; 3], 0), &tagged_box([5.0; 3], [10.0; 3], 1), BooleanOp::Union);+ }++ /// A slot across the top of a 20 mm cube: the top is cut in two, the slot's walls and floor+ /// come from the tool.+ #[test]+ fn a_slot_has_the_cpp_history() {+ let _cpp = crate::route::on_cpp();+ let (a, b) = (tagged_box([0.0; 3], [20.0; 3], 0), tagged_box([5.0, -1.0, 10.0], [10.0, 22.0, 15.0], 1));+ parity(&a, &b, BooleanOp::Subtract);+ }++ /// Two boxes side by side, sharing the face x = 10 and their top and bottom planes: faces+ /// found lying on each other's (SMLib's coincidences and merges) stand for both.+ #[test]+ fn boxes_side_by_side_have_the_cpp_history() {+ let _cpp = crate::route::on_cpp();+ let (a, b) = (tagged_box([0.0; 3], [10.0; 3], 0), tagged_box([10.0, 0.0, 0.0], [10.0; 3], 1));+ parity(&a, &b, BooleanOp::Union);+ }++ /// A box sharing one corner region with another: the intersection keeps three faces of each.+ #[test]+ fn an_intersection_has_the_cpp_history() {+ let _cpp = crate::route::on_cpp();+ parity(&tagged_box([0.0; 3], [10.0; 3], 0), &tagged_box([5.0; 3], [10.0; 3], 1), BooleanOp::Intersect);+ }++ /// `SmApiBrepCopy` (the copy every solidcore operation starts from) keeps every tag: the+ /// copy's history is the operand's own, every face Kept, as on C++.+ #[test]+ fn tags_cross_a_copy() {+ let _cpp = crate::route::on_cpp();+ let a = tagged_box([0.0; 3], [10.0, 20.0, 30.0], 0);+ // Converted (and tagged) before the kernel's lock is taken: the conversion takes it too.+ let body = a.core().unwrap();+ let copy = super::run("copy", |k| {+ let g = body.0.lock().unwrap();+ solidcore::topology::brep::p3::brep_copy(k, &g)+ })+ .unwrap();+ let core = Brep::made_core(super::Body::new(copy)).history().unwrap();+ let cpp = Brep::made(ffi::copy(a.cpp().unwrap()).unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ assert!(core.faces.iter().all(|f| f.change == solidcraft_geom::brep::history::Change::Kept), "{core:?}");+ }++ /// A post standing on the top of a cube, imprinted on it: the top is split along the+ /// post's foot, the other faces are as they were.+ #[test]+ fn an_imprint_has_the_cpp_history() {+ let _cpp = crate::route::on_cpp();+ let (a, b) = (tagged_box([0.0; 3], [20.0; 3], 0), tagged_box([5.0, 5.0, 10.0], [10.0, 10.0, 20.0], 1));+ let cpp = Brep::made(ffi::ops::imprint(a.cpp().unwrap(), b.cpp().unwrap()).unwrap()).history().unwrap();+ let core = Brep::made_core(super::imprint(a.core().unwrap(), b.core().unwrap()).unwrap().unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ }++ /// A 10 mm wide bar laid across the top of a 40 x 30 x 20 block, overhanging its front and+ /// back, imprinted on it: the bar's sides cut the top in three, and cut the top edges of the+ /// faces y = 0 and y = 30 only by a vertex each (where they cross them at x = 10 and x = 20).+ /// Those faces are still all of themselves, their boundaries where they were: Kept, as are+ /// x = 0, x = 40 and the bottom (the fork's 1c7accd; before, y = 0 and y = 30 were Modified).+ #[test]+ fn a_face_whose_edge_is_only_cut_by_a_vertex_is_kept() {+ let _cpp = crate::route::on_cpp();+ use solidcraft_geom::brep::history::Change;+ let (a, b) = (tagged_box([0.0; 3], [40.0, 30.0, 20.0], 0), tagged_box([10.0, -5.0, 20.0], [10.0, 40.0, 10.0], 1));+ let cpp = Brep::made(ffi::ops::imprint(a.cpp().unwrap(), b.cpp().unwrap()).unwrap()).history().unwrap();+ let core = Brep::made_core(super::imprint(a.core().unwrap(), b.core().unwrap()).unwrap().unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ let of_a = |h: &Raw, c: Change| h.faces.iter().filter(|f| f.origins.iter().all(|o| o.0 == 0) && f.change == c).count();+ for h in [&core, &cpp] {+ assert_eq!(of_a(h, Change::Kept), 5, "{h:?}");+ assert_eq!(of_a(h, Change::Modified), 0, "{h:?}");+ }+ }++ /// A 10 mm post standing on a 20 mm cube's top against its x = 0 side, imprinted on it: the+ /// post's foot cuts the top's edge along x = 0 by two vertices. Each piece of that edge is a+ /// split child, standing for the edge and lying where it lay (the capi's Split gives an untagged+ /// child the split edge's `at`), so the side x = 0 is still all of itself and Kept.+ #[test]+ fn an_imprint_split_edge_lies_where_the_edge_lay() {+ let _cpp = crate::route::on_cpp();+ use solidcraft_geom::brep::history::Change;+ let (a, b) = (tagged_box([0.0; 3], [20.0; 3], 0), tagged_box([0.0, 5.0, 20.0], [10.0; 3], 1));+ let cpp = Brep::made(ffi::ops::imprint(a.cpp().unwrap(), b.cpp().unwrap()).unwrap()).history().unwrap();+ let core = Brep::made_core(super::imprint(a.core().unwrap(), b.core().unwrap()).unwrap().unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ let of_a = |h: &Raw, c: Change| h.faces.iter().filter(|f| f.origins.iter().all(|o| o.0 == 0) && f.change == c).count();+ for h in [&core, &cpp] {+ // The top's edge along x = 0 is in three pieces, each standing for it alone.+ let pieces = |e: usize| h.edges.iter().filter(|x| x.origins == [(0, e)]).count();+ assert!((0..12).any(|e| pieces(e) == 3), "{h:?}");+ assert_eq!(of_a(h, Change::Kept), 5, "{h:?}");+ assert_eq!(of_a(h, Change::Modified), 0, "{h:?}");+ assert_eq!(of_a(h, Change::Split), 2, "{h:?}");+ }+ }++ /// A 10 mm post standing on a 20 mm cube's top, subtracted from it: the post only touches the+ /// top, which the boolean copies the post's foot onto (`SmAttribute::Copy`). SMLib's Copy+ /// leaves a target that already has a tag alone, so the top stands for the cube's top only.+ #[test]+ fn a_copy_onto_a_tagged_face_keeps_its_own_tag() {+ let _cpp = crate::route::on_cpp();+ use solidcraft_geom::brep::history::Change;+ let (a, b) = (tagged_box([0.0; 3], [20.0; 3], 0), tagged_box([5.0, 5.0, 20.0], [10.0; 3], 1));+ parity(&a, &b, BooleanOp::Subtract);+ let core = Brep::made_core(super::boolean(a.core().unwrap(), b.core().unwrap(), BooleanOp::Subtract).unwrap().unwrap()).history().unwrap();+ assert_eq!(core.faces.len(), 6, "{core:?}");+ assert!(core.faces.iter().all(|f| f.change == Change::Kept && f.origins.len() == 1 && f.origins[0].0 == 0), "{core:?}");+ }++ /// Two 10 mm cubes side by side sharing the face x = 10, the second subtracted from the first:+ /// the second's edge on that face is copied onto the first's edge it lies on, which keeps its+ /// own tag (SMLib's Copy), as on C++.+ #[test]+ fn a_copy_onto_a_tagged_edge_has_the_cpp_history() {+ let _cpp = crate::route::on_cpp();+ parity(&tagged_box([0.0; 3], [10.0; 3], 0), &tagged_box([10.0, 0.0, 0.0], [10.0; 3], 1), BooleanOp::Subtract);+ }++ fn tagged_cylinder(origin: [f64; 3], radius: f64, height: f64, operand: usize) -> Brep {+ crate::init().unwrap();+ Brep::made(ffi::make_cylinder(&origin, radius, height).unwrap()).tagged(operand).unwrap()+ }++ /// A 40 x 40 x 10 plate with a round hole r 5 at (20, 20), made before tagging: its hole's rims+ /// are whole circles, edges closed on themselves.+ fn holed_plate(operand: usize) -> Brep {+ crate::init().unwrap();+ let plate = ffi::make_box(&[0.0; 3], &[40.0, 40.0, 10.0]).unwrap();+ let rod = ffi::make_cylinder(&[20.0, 20.0, -5.0], 5.0, 20.0).unwrap();+ Brep::made(ffi::ops::boolean(&plate, &rod, ffi::ops::BOOLEAN_SUBTRACT).unwrap()).tagged(operand).unwrap()+ }++ /// Faces of operand 0 with this change, in a history.+ fn of_first(h: &Raw, c: solidcraft_geom::brep::history::Change) -> usize {+ h.faces.iter().filter(|f| f.origins.iter().all(|o| o.0 == 0) && !f.origins.is_empty() && f.change == c).count()+ }++ /// A hole through a block: the tool's and the block's faces meet along whole circles.+ #[test]+ fn a_round_hole_has_the_cpp_history() {+ let _cpp = crate::route::on_cpp();+ parity(&tagged_box([0.0; 3], [40.0, 40.0, 10.0], 0), &tagged_cylinder([20.0, 20.0, -5.0], 5.0, 20.0, 1), BooleanOp::Subtract);+ }++ /// A corner cut far from the hole: the hole's wall keeps its two whole circles, each a closed+ /// edge still where it lay (`moved`'s `open.is_empty()`), so it is Kept on both kernels.+ #[test]+ fn a_face_bounded_by_closed_edges_is_kept() {+ let _cpp = crate::route::on_cpp();+ use solidcraft_geom::brep::history::Change;+ let (a, b) = (holed_plate(0), tagged_box([35.0, 35.0, -5.0], [10.0, 10.0, 20.0], 1));+ let cpp = Brep::made(ffi::ops::boolean(a.cpp().unwrap(), b.cpp().unwrap(), ffi::ops::BOOLEAN_SUBTRACT).unwrap()).history().unwrap();+ let core = Brep::made_core(super::boolean(a.core().unwrap(), b.core().unwrap(), BooleanOp::Subtract).unwrap().unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ // The hole's wall and the two sides the corner misses.+ assert_eq!(of_first(&core, Change::Kept), 3, "{core:?}");+ }++ /// A bar laid on the plate over the hole, imprinted: the bar's sides cross the hole's upper rim+ /// and cut that closed edge by vertices; the top is split, the wall's rim stays where it lay.+ #[test]+ fn an_imprint_cutting_a_closed_edge_has_the_cpp_history() {+ let _cpp = crate::route::on_cpp();+ let (a, b) = (holed_plate(0), tagged_box([-5.0, 18.0, 10.0], [50.0, 4.0, 5.0], 1));+ let cpp = Brep::made(ffi::ops::imprint(a.cpp().unwrap(), b.cpp().unwrap()).unwrap()).history().unwrap();+ let core = Brep::made_core(super::imprint(a.core().unwrap(), b.core().unwrap()).unwrap().unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ }++ /// A cylinder and a sphere cut by a slab across their seams (each kernel's angle 0, along +x):+ /// each curved face is split in two across its seam.+ #[test]+ fn a_curved_face_split_across_its_seam_has_the_cpp_history() {+ let _cpp = crate::route::on_cpp();+ use solidcraft_geom::brep::history::Change;+ let slab = || tagged_box([-20.0, -1.0, -20.0], [40.0, 2.0, 40.0], 1);+ let sphere = Brep::made(ffi::make_sphere(&[0.0, 0.0, 0.0], 7.0).unwrap()).tagged(0).unwrap();+ for (name, a) in [("cylinder", tagged_cylinder([0.0, 0.0, -5.0], 5.0, 10.0, 0)), ("sphere", sphere)] {+ parity(&a, &slab(), BooleanOp::Subtract);+ let cpp = Brep::made(ffi::ops::boolean(a.cpp().unwrap(), slab().cpp().unwrap(), ffi::ops::BOOLEAN_SUBTRACT).unwrap()).history().unwrap();+ assert!(of_first(&cpp, Change::Split) >= 2, "{name}: {cpp:?}");+ }+ }++ /// A chain of three overlapping boxes in one `union_all`.+ #[test]+ fn a_union_of_three_has_the_cpp_history() {+ let _cpp = crate::route::on_cpp();+ let (a, b, c) = (tagged_box([0.0; 3], [10.0; 3], 0), tagged_box([5.0; 3], [10.0; 3], 1), tagged_box([10.0; 3], [10.0; 3], 2));+ let cpp = Brep::made(ffi::ops::boolean_union_all(&[a.cpp().unwrap(), b.cpp().unwrap(), c.cpp().unwrap()]).unwrap()).history().unwrap();+ let core = Brep::made_core(super::union_all(&[a.core().unwrap(), b.core().unwrap(), c.core().unwrap()]).unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ assert_eq!(core.faces.iter().flat_map(|f| f.origins.iter().map(|o| o.0)).max(), Some(2), "{core:?}");+ }++ /// A row of four boxes sharing their top and bottom planes, united in pairs and the pairs+ /// united: each top merged with its neighbour's stands for two faces, and the merge of those+ /// stands for all four, both sources carrying several origins.+ #[test]+ fn a_merge_of_several_origins_on_each_side_has_the_cpp_history() {+ let _cpp = crate::route::on_cpp();+ let boxes: Vec<Brep> = (0..4u32).map(|i| tagged_box([f64::from(i) * 10.0, 0.0, 0.0], [10.0; 3], i as usize)).collect();+ let c = |x: usize, y: usize| ffi::ops::boolean(boxes[x].cpp().unwrap(), boxes[y].cpp().unwrap(), ffi::ops::BOOLEAN_UNION).unwrap();+ let (ab, cd) = (c(0, 1), c(2, 3));+ let cpp = Brep::made(ffi::ops::boolean(&ab, &cd, ffi::ops::BOOLEAN_UNION).unwrap()).history().unwrap();+ let s = |x: usize, y: usize| super::boolean(boxes[x].core().unwrap(), boxes[y].core().unwrap(), BooleanOp::Union).unwrap().unwrap();+ let (ab, cd) = (s(0, 1), s(2, 3));+ let core = Brep::made_core(super::boolean(&ab, &cd, BooleanOp::Union).unwrap().unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ assert!(core.faces.iter().any(|f| f.origins.len() == 4), "{core:?}");+ }++ /// Two overlapping squares combined as regions of one plane.+ #[test]+ fn a_boolean2d_has_the_cpp_history() {+ let _cpp = crate::route::on_cpp();+ use crate::sweeps::Curve;+ let square = |x: f64, y: f64, s: f64, operand: usize| {+ crate::init().unwrap();+ let c = [[x, y, 0.0], [x + s, y, 0.0], [x + s, y + s, 0.0], [x, y + s, 0.0]];+ let l: Vec<Curve> = (0..4).map(|i| Curve::Line { start: c[i], end: c[(i + 1) % 4] }).collect();+ crate::sweeps::ON_CPP.with(|f| f.set(true));+ let b = Brep::planar_faces(&l).unwrap();+ crate::sweeps::ON_CPP.with(|f| f.set(false));+ b.tagged(operand).unwrap()+ };+ let (a, b) = (square(0.0, 0.0, 10.0, 0), square(5.0, 5.0, 10.0, 1));+ for (op, code) in [+ (BooleanOp::Union, ffi::ops::BOOLEAN_UNION),+ (BooleanOp::Subtract, ffi::ops::BOOLEAN_SUBTRACT),+ (BooleanOp::Intersect, ffi::ops::BOOLEAN_INTERSECT),+ ] {+ let cpp = Brep::made(ffi::ops::boolean2d(a.cpp().unwrap(), b.cpp().unwrap(), code).unwrap()).history().unwrap();+ let core = Brep::made_core(super::boolean2d(a.core().unwrap(), b.core().unwrap(), op).unwrap().unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical(), "{op:?}");+ }+ }+}++/// Rig case booleans/2928, reduced (fork c2e3d9d): a ring, r 3..5 about (0, 10), z 0..2, unioned+/// with a half annulus prism, r 4..5 about (e, 10), z 2..20, whose cap sits on the ring's top. Two+/// equal circles a little apart cross; they do not coincide over a tiny edge. The stack's volume+/// is 113 pi whatever e is.+/// This path passes with `simple_coincidence_crossing_is_point` off too, so the test holds the+/// result here and does not single out that flag (solidcore's own test does).+#[test]+fn a_ring_and_a_lip_with_walls_nearly_together() {+ use super::sweep::extrude;+ use crate::sweeps::Curve;+ use crate::sweeps::DraftCorner;+ const Z: [f64; 3] = [0.0, 0.0, 1.0];+ let up = |p: &[Curve], d| extrude(p, Z, d, 0.0, DraftCorner::default(), true).unwrap();+ let arc = |c: [f64; 3], radius, start, end| Curve::Arc { center: c, axis: Z, reference: [1.0, 0.0, 0.0], radius, start, end };+ let disc = |r| up(&[arc([0.0, 10.0, 0.0], r, 0.0, 2.0 * PI)], 2.0);+ let ring = boolean(&disc(5.0), &disc(3.0), BooleanOp::Subtract).unwrap().unwrap();+ for e in [0.0, 1e-4, 1e-3, 1e-2] {+ let c = [e, 10.0, 2.0];+ let lip = up(+ &[+ arc(c, 5.0, 0.0, PI),+ Curve::Line { start: [e - 5.0, 10.0, 2.0], end: [e - 4.0, 10.0, 2.0] },+ Curve::Arc { center: c, axis: [0.0, 0.0, -1.0], reference: [-1.0, 0.0, 0.0], radius: 4.0, start: 0.0, end: PI },+ Curve::Line { start: [e + 4.0, 10.0, 2.0], end: [e + 5.0, 10.0, 2.0] },+ ],+ 18.0,+ );+ let u = boolean(&ring, &lip, BooleanOp::Union).unwrap().unwrap();+ let v = volume(&u, 1e-8).unwrap();+ let report = super::check(&u, crate::check::CheckLevel::All).unwrap();+ assert!(report.is_valid(), "e {e}: {report}");+ assert_eq!(solid_count(&u).unwrap(), 1, "e {e}");+ assert!(super::is_manifold_solid(&u).unwrap(), "e {e}");+ assert!((v - 113.0 * PI).abs() < 1e-3, "e {e}: {v}");+ }+}diff --git a/crates/smlib/src/core/convert.rs b/crates/smlib/src/core/convert.rsnew file mode 100644index 0000000000..56988f618b--- /dev/null+++ b/crates/smlib/src/core/convert.rs@@ -0,0 +1,2604 @@+//! solidcore's B-rep to and from the C API's flat arrays ([`crate::flat`]): ports of+//! `capi/src/smlib_flat.cpp`, so a body converts exactly as it does through the C++ kernel.+//! - [`to_arrays`]: `FlatFromBrep` (SmBrep, through `SmBrepData::FromBrep`, to arrays): the same+//! ids, the same face, edge and vertex order (`GetFaces`, `GetEdges`), analytic kinds with+//! ranges in radians, NURBS as splines, SMLib's own UV trims and tolerances.+//! - [`from_arrays`]: `BrepFromFlat` (`Validate`, `FlatToBrepData`, then+//! `SmBrep::MakeTopologyFromData`, healing unless the arrays say SMLib wrote them).+//!+//! Tolerances differ from the C++ on purpose: `to_arrays` writes the B-rep's own tolerance as+//! TOLERANCE, not the largest of its entities', and `from_arrays` takes the B-rep's and the faces'+//! from the edges' and vertices' own ([`own_tolerances`]). Each entity keeps its tolerance across+//! the kernels instead of every one taking the largest at each crossing.+//!+//! A face whose surface is not a B-spline kind (an offset) exports its approximation, as+//! `FlatFromBrep` does (`SmSurface::ApproximateSurface`).+//!+//! [`from_arrays`] also runs the capi's `PutEnclosingShellsFirst` ([`put_enclosing_shells_first`],+//! an addition to SmuConvert): a bounded region of several shells starts its list at the shell+//! `SmShell::IsInnerShellOf` shows enclosing the others, whatever order the arrays gave.++// The SmBrepData records are filled field by field, as FlatToBrepData fills them after ReSet.+#![allow(clippy::field_reassign_with_default)]++use std::borrow::Cow;+use std::collections::HashMap;++use solidcore::curve::curve::p1::ApproximateCurveOptions;+use solidcore::curve::curve::{Curve, CurveKind};+use solidcore::curve::ellipse::{Ellipse, EllipseOptions};+use solidcore::curve::line::Line;+use solidcore::geom::attribute::{AttributeStore, ObjectKey};+use solidcore::geom::axis2_placement::Axis2Placement;+use solidcore::geom::extent1d::Extent1d;+use solidcore::geom::extent2d::Extent2d;+use solidcore::geom::object::ObjectRef;+use solidcore::geom::tol::approx_tol3d;+use solidcore::nurbs::b_spline_curve::{BSplineCurve, BSplineCurveForm, CanonicalData, KnotType};+use solidcore::nurbs::b_spline_surface::{BSplineSurface, BSplineSurfaceForm, CanonicalSurfaceData};+use solidcore::nurbs::crv_basic::Curve as NurbCurve;+use solidcore::nurbs::math::{CPoint, NOW, NOZ};+use solidcore::nurbs::srf_basic::Surface as NurbSurface;+use solidcore::query::brep::{BoundingBoxOptions, calculate_bounding_box};+use solidcore::surface::cone::Cone;+use solidcore::surface::plane::Plane;+use solidcore::surface::sphere::Sphere;+use solidcore::surface::surface::{Surface, SurfaceKind};+use solidcore::surface::torus::{Torus, TorusOptions};+use solidcore::topology::brep::p1 as bl;+use solidcore::topology::brep::p10::{HEALER_VERSION, MakeTopologyOptions, TopologyEnv, make_topology_from_data};+use solidcore::topology::brep_data::{+ BrepData, DataSourceType, EdgeData, EuData, FaceData, FaceuseData, Keyed, LoopData, NO_OBJECT, RegionData, ShellData, UNDEF_ULONG, UNSURE,+ VertexData,+};+use solidcore::topology::brep_data_write::FromBrepEnv;+use solidcore::topology::edgeuse::{p1 as eu1, p3 as eu3};+use solidcore::topology::topology::NotifyRecords;+use solidcore::topology::{Brep, EdgeId, EdgeuseId, FaceId, ShellId, VertexId, edge, shell, vertex};+use solidcore::{EntityRef, Kernel, Point2, Point3, SolidError, Vec3};++use crate::flat::*;+use crate::import::Arrays;+use crate::{Error, Result};++use super::{Body, answer, run, with_body};++// ---- shared ------------------------------------------------------------------------------------++/// A solidcore error from `call`.+fn sc(call: &'static str) -> impl Fn(SolidError) -> Error {+ move |e| Error::Solidcore(format!("{call}: {e}"))+}++/// The arrays (or the body) are not what the conversion can carry: SMLib's `SM_ERR`.+fn bad(what: &str) -> Error {+ Error::Solidcore(format!("flat arrays: {what}"))+}++fn get<T: Copy>(v: &[T], i: usize) -> Result<T> {+ v.get(i).copied().ok_or_else(|| bad("index past its array"))+}++fn get3(v: &[f64], i: usize) -> Result<Vec3> {+ let at = |k: usize| i.checked_mul(3).and_then(|j| j.checked_add(k)).map_or_else(|| Err(bad("index past its array")), |j| get(v, j));+ Ok(Vec3::new(at(0)?, at(1)?, at(2)?))+}++fn idx(x: i64) -> Result<usize> {+ usize::try_from(x).map_err(|_| bad("negative index"))+}++fn count(n: usize) -> Result<i64> {+ i64::try_from(n).map_err(|_| bad("count"))+}++fn index_u64(x: u64) -> Result<usize> {+ usize::try_from(x).map_err(|_| bad("index"))+}++/// `SM_DEG2RAD`.+fn deg2rad(d: f64) -> f64 {+ d * (std::f64::consts::PI / 180.0)+}++/// `SM_RAD2DEG`.+fn rad2deg(r: f64) -> f64 {+ r * (180.0 / std::f64::consts::PI)+}++/// `SnapSMLibAngularBoundaryDeg`.+fn snap_angular_boundary_deg(degrees: f64) -> f64 {+ for quarter in -4..=4 {+ let boundary = 90.0 * f64::from(quarter);+ if (degrees - boundary).abs() <= 1.0e-9 {+ return boundary;+ }+ }+ degrees+}++/// `UsdRadiansToSMLibDegrees`.+fn radians_to_smlib_degrees(radians: f64) -> f64 {+ snap_angular_boundary_deg(rad2deg(radians))+}++/// `SM_INFINITE_PARAMETER`.+const INFINITE_PARAMETER: f64 = 1_234_567.0;+/// `SM_EFF_ZERO`.+const EFF_ZERO: f64 = 1.0e-12;+/// `SM_IS_INFINITE`.+fn is_infinite(a: f64) -> bool {+ a.abs() == INFINITE_PARAMETER || a.abs() == 1111.111+}++/// The flat arrays' writer: every array id, empty until written.+struct Out(Arrays);++impl Out {+ fn new() -> Out {+ let mut a = Arrays::default();+ for id in 1..=WIRE_EDGE_NURBS_FORM {+ a.ints.insert(id, Vec::new());+ }+ for id in TOLERANCE..=VERTEX_TOLERANCE {+ a.reals.insert(id, Vec::new());+ }+ Out(a)+ }+ fn i(&mut self, id: i32) -> &mut Vec<i64> {+ self.0.ints.entry(id).or_default()+ }+ fn r(&mut self, id: i32) -> &mut Vec<f64> {+ self.0.reals.entry(id).or_default()+ }+ fn r3(&mut self, id: i32, p: Vec3) {+ self.r(id).extend([p.x, p.y, p.z]);+ }+}++/// The arrays of one edge family (edges or wire edges), by id (`EdgeArraysOut`).+struct EdgeIds {+ ty: i32,+ range: i32,+ count: i32,+ order: i32,+ cvs: i32,+ knots: i32,+ weights: i32,+ circle_center: i32,+ circle_axis: i32,+ circle_ref: i32,+ circle_radius: i32,+ line_origin: i32,+ line_direction: i32,+ ellipse_center: i32,+ ellipse_axis: i32,+ ellipse_ref: i32,+ ellipse_x: i32,+ ellipse_y: i32,+ form: i32,+ vertices: i32,+}++const EDGES: EdgeIds = EdgeIds {+ ty: EDGE_CURVE_TYPE,+ range: EDGE_RANGE,+ count: EDGE_NURBS_VERTEX_COUNT,+ order: EDGE_NURBS_ORDER,+ cvs: EDGE_NURBS_CVS,+ knots: EDGE_NURBS_KNOTS,+ weights: EDGE_NURBS_WEIGHTS,+ circle_center: EDGE_CIRCLE_CENTER,+ circle_axis: EDGE_CIRCLE_AXIS,+ circle_ref: EDGE_CIRCLE_REF_DIRECTION,+ circle_radius: EDGE_CIRCLE_RADIUS,+ line_origin: EDGE_LINE_ORIGIN,+ line_direction: EDGE_LINE_DIRECTION,+ ellipse_center: EDGE_ELLIPSE_CENTER,+ ellipse_axis: EDGE_ELLIPSE_AXIS,+ ellipse_ref: EDGE_ELLIPSE_REF_DIRECTION,+ ellipse_x: EDGE_ELLIPSE_X_RADIUS,+ ellipse_y: EDGE_ELLIPSE_Y_RADIUS,+ form: EDGE_NURBS_FORM,+ vertices: EDGE_VERTICES,+};++const WIRE_EDGES: EdgeIds = EdgeIds {+ ty: WIRE_EDGE_CURVE_TYPE,+ range: WIRE_EDGE_RANGE,+ count: WIRE_EDGE_NURBS_VERTEX_COUNT,+ order: WIRE_EDGE_NURBS_ORDER,+ cvs: WIRE_EDGE_NURBS_CVS,+ knots: WIRE_EDGE_NURBS_KNOTS,+ weights: WIRE_EDGE_NURBS_WEIGHTS,+ circle_center: WIRE_EDGE_CIRCLE_CENTER,+ circle_axis: WIRE_EDGE_CIRCLE_AXIS,+ circle_ref: WIRE_EDGE_CIRCLE_REF_DIRECTION,+ circle_radius: WIRE_EDGE_CIRCLE_RADIUS,+ line_origin: WIRE_EDGE_LINE_ORIGIN,+ line_direction: WIRE_EDGE_LINE_DIRECTION,+ ellipse_center: WIRE_EDGE_ELLIPSE_CENTER,+ ellipse_axis: WIRE_EDGE_ELLIPSE_AXIS,+ ellipse_ref: WIRE_EDGE_ELLIPSE_REF_DIRECTION,+ ellipse_x: WIRE_EDGE_ELLIPSE_X_RADIUS,+ ellipse_y: WIRE_EDGE_ELLIPSE_Y_RADIUS,+ form: WIRE_EDGE_NURBS_FORM,+ vertices: WIRE_EDGE_VERTICES,+};++const CURVE_NURBS_I: i64 = CURVE_NURBS as i64;+const CURVE_LINE_I: i64 = CURVE_LINE as i64;+const CURVE_CIRCLE_I: i64 = CURVE_CIRCLE as i64;+const CURVE_ELLIPSE_I: i64 = CURVE_ELLIPSE as i64;+const SURFACE_NURBS_I: i64 = SURFACE_NURBS as i64;+const SURFACE_PLANE_I: i64 = SURFACE_PLANE as i64;+const SURFACE_CYLINDER_I: i64 = SURFACE_CYLINDER as i64;+const SURFACE_CONE_I: i64 = SURFACE_CONE as i64;+const SURFACE_SPHERE_I: i64 = SURFACE_SPHERE as i64;+const SURFACE_TORUS_I: i64 = SURFACE_TORUS as i64;++/// The `SmBSplineCurve` part of a curve that is one (`IsKindOf(SmBSplineCurve_TYPE)`), with its+/// NURB (`GetOrCreateGwNurbPointer`: a lazy line or conic makes it on a copy); `None` for the+/// other kinds.+pub(super) fn bspline_curve_part<'c>(k: &Kernel, c: &'c Curve) -> Result<Option<Cow<'c, BSplineCurve>>> {+ Ok(Some(match c.kind() {+ CurveKind::BSpline(b) => Cow::Borrowed(b),+ CurveKind::Line(l) => l.base_with_nurb().map_err(sc("SmLine::GetOrCreateGwNurbPointer"))?,+ CurveKind::Ellipse(e) if e.base().gw_nurb().is_none() => {+ let mut made = e.clone();+ made.make_nurb(k).map_err(sc("SmEllipse::MakeNurb"))?;+ Cow::Owned(made.base().clone_exact())+ }+ CurveKind::Ellipse(e) => Cow::Borrowed(e.base()),+ CurveKind::Hyperbola(h) if h.base().gw_nurb().is_none() => {+ let mut made = h.clone();+ made.make_nurb(None).map_err(sc("SmHyperbola::MakeNurb"))?;+ Cow::Owned(made.base().clone_exact())+ }+ CurveKind::Hyperbola(h) => Cow::Borrowed(h.base()),+ CurveKind::Parabola(p) if p.base().gw_nurb().is_none() => {+ let mut made = p.clone();+ made.make_nurb(None).map_err(sc("SmParabola::MakeNurb"))?;+ Cow::Owned(made.base().clone_exact())+ }+ CurveKind::Parabola(p) => Cow::Borrowed(p.base()),+ _ => return Ok(None),+ }))+}++/// The `SmBSplineSurface` part of a surface that is one (`IsKindOf(SmBSplineSurface_TYPE)`), its+/// NURB made first (`GetOrCreateGwNurbPointer`); `None` for the other kinds.+fn bspline_surface_part<'s>(k: &Kernel, s: &'s Surface) -> Result<Option<&'s BSplineSurface>> {+ Ok(match s.kind_with_nurb(k).map_err(sc("SmSurface::GetOrCreateGwNurbPointer"))? {+ SurfaceKind::BSpline(b) => Some(b),+ SurfaceKind::Plane(p) => Some(p.base()),+ SurfaceKind::Cone(c) => Some(c.rev().base()),+ SurfaceKind::Sphere(s) => Some(s.base().base()),+ SurfaceKind::Torus(t) => Some(t.base().base()),+ SurfaceKind::SurfOfRevolution(r) => Some(r.base()),+ SurfaceKind::SurfOfExtrusion(e) => Some(e.base()),+ _ => None,+ })+}++// ---- export: FlatFromBrep ----------------------------------------------------------------------++/// `body` as the flat arrays the C API exports (`FlatFromBrep`).+pub(crate) fn to_arrays(body: &Body) -> Result<Arrays> {+ with_body("FlatFromBrep", body, |k, b| Ok(flat_from_brep(k, b)))?+}++/// One NURBS curve's arrays (`smu_AddSmBSplineCurve3d`, `smu_AddSmBSplineCurve2d`): counts and+/// orders, cartesian control points of `dim` coordinates, knots and weights.+struct NurbsOut<'a> {+ count: &'a mut Vec<i64>,+ order: &'a mut Vec<i64>,+ cvs: &'a mut Vec<f64>,+ knots: &'a mut Vec<f64>,+ weights: &'a mut Vec<f64>,+}++/// `smu_AddSmBSplineCurve3d`: the curve's NURB, its control points made cartesian.+fn add_bspline_curve_3d(nurb: &NurbCurve, o: NurbsOut<'_>) -> Result<()> {+ o.count.push(count(nurb.cpts().len())?);+ o.order.push(count(nurb.degree())?.saturating_add(1));+ o.knots.extend_from_slice(nurb.knots());+ for p in nurb.cpts() {+ let (mut x, mut y, mut z, mut w) = (p.x, p.y, p.z, 1.0);+ if p.w != NOW {+ x /= p.w;+ y /= p.w;+ z /= p.w;+ w = p.w;+ }+ o.cvs.extend([x, y, z]);+ o.weights.push(w);+ }+ Ok(())+}++/// The NURB of a B-spline part (`GetOrCreateGwNurbPointer`, NULL being `SM_ERR`).+fn nurb_of(part: &BSplineCurve) -> Result<&NurbCurve> {+ part.gw_nurb().ok_or_else(|| bad("a B-spline curve without its NURB"))+}++/// `smu_AddSmBSplineCurve2d`: an edgeuse's UV trim, reversed when the edgeuse runs against its+/// edge; `None` appends the empty curve. `remap` maps the knots from the edge's interval+/// `[remap[0], remap[1]]` onto `[remap[2], remap[3]]`, `affine` the face's NURBS (u, v) onto the+/// arrays' plane (u, v).+fn add_bspline_curve_2d(o: &mut Out, trim: Option<&NurbCurve>, same: bool, remap: Option<[f64; 4]>, affine: Option<[f64; 6]>) -> Result<()> {+ let Some(nurb) = trim else {+ o.i(EDGEUSE_NURBS_VERTEX_COUNT).push(0);+ o.i(EDGEUSE_NURBS_ORDER).push(0);+ return Ok(());+ };+ let reversed;+ let nurb = if same {+ nurb+ } else {+ reversed = nurb.reversed().map_err(sc("N_CrvReverse"))?;+ &reversed+ };+ o.i(EDGEUSE_NURBS_VERTEX_COUNT).push(count(nurb.cpts().len())?);+ o.i(EDGEUSE_NURBS_ORDER).push(count(nurb.degree())?.saturating_add(1));+ for &k in nurb.knots() {+ let k = match remap {+ Some(r) if k == r[1] => r[3],+ Some(r) => r[2] + (k - r[0]) / (r[1] - r[0]) * (r[3] - r[2]),+ None => k,+ };+ o.r(EDGEUSE_NURBS_KNOTS).push(k);+ }+ for p in nurb.cpts() {+ let (mut x, mut y, mut w) = (p.x, p.y, 1.0);+ if p.w != NOW {+ x /= p.w;+ y /= p.w;+ w = p.w;+ }+ if let Some(a) = affine {+ let ax = a[0] + a[1] * x + a[2] * y;+ y = a[3] + a[4] * x + a[5] * y;+ x = ax;+ }+ o.r(EDGEUSE_NURBS_CVS).extend([x, y]);+ o.r(EDGEUSE_NURBS_WEIGHTS).push(w);+ }+ Ok(())+}++/// `smu_AddSmBSplineSurface`: a surface's NURB, control points U-major and cartesian. A knot+/// vector without extent is `SM_ERR`.+fn add_bspline_surface(o: &mut Out, nurb: &NurbSurface) -> Result<()> {+ let (u, v) = (nurb.u_knots(), nurb.v_knots());+ let spans = |k: &[f64]| matches!((k.first(), k.last()), (Some(a), Some(b)) if a < b);+ if !spans(u) || !spans(v) {+ return Err(bad("NURBS surface has degenerate knots and can't be converted"));+ }+ let (nu, nv) = (nurb.n().saturating_add(1), nurb.m().saturating_add(1));+ o.i(FACE_NURBS_U_VERTEX_COUNT).push(count(nu)?);+ o.i(FACE_NURBS_V_VERTEX_COUNT).push(count(nv)?);+ o.i(FACE_NURBS_U_ORDER).push(count(nurb.p())?.saturating_add(1));+ o.i(FACE_NURBS_V_ORDER).push(count(nurb.q())?.saturating_add(1));+ o.r(FACE_NURBS_U_KNOTS).extend_from_slice(u);+ o.r(FACE_NURBS_V_KNOTS).extend_from_slice(v);+ for row in nurb.rows() {+ if row.len() != nv {+ return Err(bad("NURBS surface net"));+ }+ for p in row {+ let (mut x, mut y, mut z, mut w) = (p.x, p.y, p.z, 1.0);+ if p.w != NOW {+ w = p.w;+ x /= w;+ y /= w;+ z /= w;+ }+ o.r3(FACE_NURBS_CVS, Vec3::new(x, y, z));+ o.r(FACE_NURBS_WEIGHTS).push(w);+ }+ }+ Ok(())+}++/// `smu_CompactLocalIndex`: a BrepData index less the sorted removed indices below it.+fn compact_index(i: u64, removed: &[u64]) -> Result<i64> {+ let below = removed.partition_point(|&r| r < i);+ count(index_u64(i)?.saturating_sub(below))+}++/// `EdgeCurveAsBSpline`: an edge curve's B-spline part, else its approximation within+/// `approx_tol` over the edge interval (`ApproximateCurve`); `None` when it has neither.+fn edge_curve_as_bspline<'c>(k: &Kernel, c: &'c Curve, ivl: &Extent1d, approx_tol: f64) -> Result<Option<Cow<'c, BSplineCurve>>> {+ if let Some(part) = bspline_curve_part(k, c)? {+ return Ok(Some(part));+ }+ let Ok(approx) = c.approximate_curve(k, &[ivl.min(), ivl.max()], approx_tol, &ApproximateCurveOptions::default()) else {+ return Ok(None);+ };+ Ok(bspline_curve_part(k, &approx.curve)?.map(|p| Cow::Owned(p.clone_exact())))+}++/// `BuildAnalyticEdgeCurve`: the curve the import builds for a line (unbounded,+/// `center + s * axis`), circle or ellipse (over `[d_min, d_max]` degrees, its NURBS parameter+/// then set to that interval with its notification, `EditParameterization`).+fn build_analytic_edge_curve(k: &Kernel, ty: i64, d_min: f64, d_max: f64, center: Point3, axis: Vec3, refd: Vec3, r1: f64, r2: f64) -> Result<Curve> {+ analytic_edge_curve(k, ty, d_min, d_max, center, axis, refd, r1, r2).map_err(|(call, e)| sc(call)(e))+}++/// [`build_analytic_edge_curve`] with solidcore's own error, and the call that gave it.+#[allow(clippy::too_many_arguments)] // BuildAnalyticEdgeCurve's+fn analytic_edge_curve(+ k: &Kernel,+ ty: i64,+ d_min: f64,+ d_max: f64,+ center: Point3,+ axis: Vec3,+ refd: Vec3,+ r1: f64,+ r2: f64,+) -> std::result::Result<Curve, (&'static str, SolidError)> {+ if ty == CURVE_LINE_I {+ return Ok(Curve::from(Line::create_canonical(center, axis)));+ }+ let mut placement = Axis2Placement::default();+ placement.set_canonical(center, refd, axis.cross(refd)).map_err(|e| ("SmAxis2Placement::SetCanonical", e))?;+ let degrees = Extent1d::from_min_max(d_min, d_max);+ let mut e = if ty == CURVE_CIRCLE_I {+ Ellipse::create_canonical_circle(k, &placement, r1, Some(°rees), None).map_err(|e| ("SmCircle::CreateCanonical", e))?+ } else {+ Ellipse::create_canonical(k, &placement, r1, r2, Some(°rees), None).map_err(|e| ("SmEllipse::CreateCanonical", e))?+ };+ e.edit_parameterization(k, °rees, true, None).map_err(|e| ("SmEllipse::EditParameterization", e))?;+ Ok(Curve::from(e))+}++/// How one edge's curve is exported (`EdgeExport`).+#[derive(Clone, Copy)]+struct EdgeExport {+ ty: i64,+ /// The exported range: radians for circles and ellipses.+ lo: f64,+ hi: f64,+ /// The imported edge's interval, in SMLib units (degrees for circles and ellipses).+ sm_lo: f64,+ sm_hi: f64,+ center: Point3,+ axis: Vec3,+ refd: Vec3,+ r1: f64,+ r2: f64,+ /// The imported curve's parameter is an affine image of the edge's.+ affine: bool,+}++const NURBS_EXPORT: EdgeExport = EdgeExport {+ ty: CURVE_NURBS_I,+ lo: 0.0,+ hi: 0.0,+ sm_lo: 0.0,+ sm_hi: 0.0,+ center: Vec3::new(0.0, 0.0, 0.0),+ axis: Vec3::new(0.0, 0.0, 0.0),+ refd: Vec3::new(0.0, 0.0, 0.0),+ r1: 0.0,+ r2: 0.0,+ affine: false,+};++/// `ClassifyEdgeCurve`: a circle, ellipse or line kept as its kind when the curve the import+/// builds from it ([`build_analytic_edge_curve`]) matches it pointwise at the edge's ends and+/// along the STEP parameter; anything else NURBS. A curve whose STEP parameter runs against its+/// NURBS one goes with its axis reversed and its range negated. A call that returns a status+/// other than success makes the edge NURBS, as there ([`answer`]); any other solidcore error+/// fails the export.+fn classify_edge_curve(k: &Kernel, c: Option<&Curve>, ivl: &Extent1d) -> Result<EdgeExport> {+ let Some(c) = c else { return Ok(NURBS_EXPORT) };+ Ok(classify(k, c, ivl).map_err(sc("ClassifyEdgeCurve"))?.unwrap_or(NURBS_EXPORT))+}++fn classify(k: &Kernel, c: &Curve, ivl: &Extent1d) -> std::result::Result<Option<EdgeExport>, SolidError> {+ let mut e = NURBS_EXPORT;+ match c.kind() {+ CurveKind::Ellipse(el) => {+ let can = el.canonical();+ e.ty = if el.is_circle_class() { CURVE_CIRCLE_I } else { CURVE_ELLIPSE_I };+ e.center = can.position.origin();+ e.axis = can.position.z_axis();+ e.refd = can.position.x_axis();+ e.r1 = can.radius_x;+ e.r2 = if el.is_circle_class() { can.radius_x } else { can.radius_y };+ }+ CurveKind::Line(l) => {+ let can = l.canonical();+ e.ty = CURVE_LINE_I;+ e.center = can.point;+ e.axis = can.vector;+ }+ _ => return Ok(None),+ }+ let mut s0 = {+ let Some(x) = answer(c.convert_t_from_nurbs_to_step(k, ivl.min()))? else { return Ok(None) };+ x+ };+ let mut s1 = {+ let Some(x) = answer(c.convert_t_from_nurbs_to_step(k, ivl.max()))? else { return Ok(None) };+ x+ };+ if !s0.is_finite() || !s1.is_finite() {+ return Ok(None);+ }+ // sNew = sign * sOld + shift+ let (mut sign, mut shift) = (1.0, 0.0);+ if s0 > s1 {+ sign = -1.0;+ s0 = -s0;+ s1 = -s1;+ e.axis = Vec3::new(-e.axis.x, -e.axis.y, -e.axis.z);+ }+ if !(s1 > s0) {+ return Ok(None);+ }+ if e.ty == CURVE_LINE_I {+ if s0.abs() > INFINITE_PARAMETER || s1.abs() > INFINITE_PARAMETER {+ return Ok(None);+ }+ (e.lo, e.sm_lo, e.hi, e.sm_hi) = (s0, s0, s1, s1);+ } else {+ // SmCircle/SmEllipse::CreateCanonical take intervals within [-360, 360] degrees. (Not+ // in the C++: angles past a million degrees are refused, bounding the loops below.)+ if s1 - s0 > 360.0 + 1e-9 || s0.abs() > 1.0e6 || s1.abs() > 1.0e6 {+ return Ok(None);+ }+ while s1 > 360.0 + 1e-9 {+ s0 -= 360.0;+ s1 -= 360.0;+ shift -= 360.0;+ }+ while s0 < -360.0 - 1e-9 {+ s0 += 360.0;+ s1 += 360.0;+ shift += 360.0;+ }+ if s1 > 360.0 + 1e-9 {+ return Ok(None);+ }+ e.lo = deg2rad(s0);+ e.hi = deg2rad(s1);+ // exactly what the import computes+ e.sm_lo = radians_to_smlib_degrees(e.lo);+ e.sm_hi = radians_to_smlib_degrees(e.hi);+ }++ let built = {+ let Some(x) = answer(analytic_edge_curve(k, e.ty, e.sm_lo, e.sm_hi, e.center, e.axis, e.refd, e.r1, e.r2).map_err(|(_, e)| e))? else {+ return Ok(None);+ };+ x+ };+ let a = {+ let Some(x) = answer(c.evaluate_point(k, ivl.min()))? else { return Ok(None) };+ x+ };+ let b = {+ let Some(x) = answer(c.evaluate_point(k, ivl.max()))? else { return Ok(None) };+ x+ };+ let tol = 1e-9 * (1.0 + e.r1 + e.r2 + a.max_dimension() + b.max_dimension());+ let mut affine = true;+ for step in 0..=8 {+ let f = f64::from(step) / 8.0;+ // the same point by the STEP parameter of each curve+ let s_new = e.sm_lo + f * (e.sm_hi - e.sm_lo);+ let s_old = (s_new - shift) * sign;+ let t_old = {+ let Some(x) = answer(c.convert_t_from_step_to_nurbs(k, s_old))? else { return Ok(None) };+ x+ };+ let t_new = {+ let Some(x) = answer(built.convert_t_from_step_to_nurbs(k, s_new))? else { return Ok(None) };+ x+ };+ let p_old = {+ let Some(x) = answer(c.evaluate_point(k, t_old))? else { return Ok(None) };+ x+ };+ let p_new = {+ let Some(x) = answer(built.evaluate_point(k, t_new))? else { return Ok(None) };+ x+ };+ if !(p_old.distance(p_new) <= tol) {+ return Ok(None);+ }+ // the same point by each edge's NURBS parameter, affinely matched+ let q_old = {+ let Some(x) = answer(c.evaluate_point(k, ivl.min() + f * (ivl.max() - ivl.min())))? else { return Ok(None) };+ x+ };+ let q_new = {+ let Some(x) = answer(built.evaluate_point(k, e.sm_lo + f * (e.sm_hi - e.sm_lo)))? else { return Ok(None) };+ x+ };+ let d = q_old.distance(q_new);+ if (step == 0 || step == 8) && !(d <= tol) {+ return Ok(None); // the ends must match exactly as the edge's vertices do+ }+ affine = affine && d <= tol;+ }+ e.affine = affine;+ Ok(Some(e))+}++/// `WriteEdgeCurve`: one edge's kind, range and geometry. A circle or ellipse also goes with its+/// own NURBS form (`*_NURBS_FORM`), whose interval its range is.+fn write_edge_curve(k: &Kernel, o: &mut Out, ids: &EdgeIds, e: &EdgeExport, c: Option<&Curve>, ivl: &Extent1d, approx_tol: f64) -> Result<()> {+ o.i(ids.ty).push(e.ty);+ let form = e.ty == CURVE_CIRCLE_I || e.ty == CURVE_ELLIPSE_I;+ o.i(ids.form).push(i64::from(form));+ let c = c.ok_or_else(|| bad("an edge without a curve"))?;+ let nurbs = |o: &mut Out, part: &BSplineCurve| -> Result<()> {+ let (mut count, mut order, mut cvs, mut knots, mut weights) = (Vec::new(), Vec::new(), Vec::new(), Vec::new(), Vec::new());+ add_bspline_curve_3d(+ nurb_of(part)?,+ NurbsOut { count: &mut count, order: &mut order, cvs: &mut cvs, knots: &mut knots, weights: &mut weights },+ )?;+ o.i(ids.count).append(&mut count);+ o.i(ids.order).append(&mut order);+ o.r(ids.cvs).append(&mut cvs);+ o.r(ids.knots).append(&mut knots);+ o.r(ids.weights).append(&mut weights);+ Ok(())+ };+ if e.ty == CURVE_NURBS_I {+ o.r(ids.range).extend([ivl.min(), ivl.max()]);+ // SmuConvert asserts and dereferences NULL+ let part = edge_curve_as_bspline(k, c, ivl, approx_tol)?.ok_or_else(|| bad("an edge curve SMLib could not approximate"))?;+ return nurbs(o, &part);+ }+ if form {+ o.r(ids.range).extend([ivl.min(), ivl.max()]);+ } else {+ o.r(ids.range).extend([e.lo, e.hi]);+ }+ if e.ty == CURVE_LINE_I {+ o.r3(ids.line_origin, e.center);+ o.r3(ids.line_direction, e.axis);+ return Ok(());+ }+ if e.ty == CURVE_CIRCLE_I {+ o.r3(ids.circle_center, e.center);+ o.r3(ids.circle_axis, e.axis);+ o.r3(ids.circle_ref, e.refd);+ o.r(ids.circle_radius).push(e.r1);+ } else {+ o.r3(ids.ellipse_center, e.center);+ o.r3(ids.ellipse_axis, e.axis);+ o.r3(ids.ellipse_ref, e.refd);+ o.r(ids.ellipse_x).push(e.r1);+ o.r(ids.ellipse_y).push(e.r2);+ }+ // every SMLib conic is an SmBSplineCurve: its own NURBS, in edge order with the NURBS+ // edges' curves+ let part = bspline_curve_part(k, c)?.ok_or_else(|| bad("a conic that is not a B-spline"))?;+ nurbs(o, &part)+}++/// `ZoneTolWithFaces`: `own` or, where larger, the B-rep's tolerance or that of a face round it.+fn zone_tol_with_faces(b: &Brep, own: f64, brep_tol: f64, faces: &[FaceId]) -> Result<f64> {+ let mut tol = own.max(brep_tol);+ for &f in faces {+ let t = solidcore::topology::face::p2::tolerance(b, f).map_err(sc("SmFace::GetTolerance"))?;+ if t.is_finite() && t > tol {+ tol = t;+ }+ }+ Ok(tol)+}++/// `GetMaxZoneTol3d`: the largest of the B-rep's, its faces', edges' and vertices' tolerances.+fn max_zone_tol(b: &Brep) -> Result<f64> {+ let mut max = b.tolerance();+ let mut take = |t: f64| {+ if t.is_finite() && t >= 0.0 && t > max {+ max = t;+ }+ };+ for f in bl::faces(b, None).map_err(sc("GetFaces"))? {+ take(solidcore::topology::face::p2::tolerance(b, f).map_err(sc("SmFace::GetTolerance"))?);+ }+ for e in bl::edges(b, None).map_err(sc("GetEdges"))? {+ take(edge::tolerance(b, e).map_err(sc("SmEdge::GetTolerance"))?);+ }+ for v in bl::vertices(b, None).map_err(sc("GetVertices"))? {+ take(vertex::tolerance(b, v).map_err(sc("SmVertex::GetTolerance"))?);+ }+ Ok(max)+}++/// The shells in `SmBrepData::FromBrep`'s order: the regions, the infinite one first, each+/// region's shells in list order.+fn shells_in_order(b: &Brep) -> Result<Vec<ShellId>> {+ let mut regions = bl::regions(b, None).map_err(sc("GetRegions"))?;+ let infinite = b.infinite_region();+ if regions.len() > 1+ && regions.first().copied() != infinite+ && let Some(i) = regions.iter().skip(1).position(|&r| Some(r) == infinite)+ {+ let r = regions.remove(i + 1);+ regions.insert(0, r);+ }+ let mut shells = Vec::new();+ for r in regions {+ shells.extend(b.region(r).map_err(sc("GetShells"))?.shells.iter().copied());+ }+ Ok(shells)+}++/// The topology identity [`BrepData::from_brep`] and [`make_topology_from_data`] name entities+/// by (upstream: their addresses): the type code and the entity's index.+pub(crate) fn key_of(e: EntityRef) -> ObjectRef {+ let (type_code, kind, i) = match e {+ EntityRef::Brep(x) => (16011, 0u64, x.index()),+ EntityRef::Region(x) => (16012, 1, x.index()),+ EntityRef::Shell(x) => (16013, 2, x.index()),+ EntityRef::Faceuse(x) => (16022, 3, x.index()),+ EntityRef::Face(x) => (16002, 4, x.index()),+ EntityRef::Loopuse(x) => (16004, 5, x.index()),+ EntityRef::Loop(x) => (16003, 6, x.index()),+ EntityRef::Edgeuse(x) => (16005, 7, x.index()),+ EntityRef::Edge(x) => (16016, 8, x.index()),+ EntityRef::Vertexuse(x) => (16006, 9, x.index()),+ EntityRef::Vertex(x) => (16021, 10, x.index()),+ };+ ObjectRef { type_code, key: ObjectKey(((kind + 1) << 32) | u64::from(i)) }+}++/// `FlatFromBrep`: `b` as flat arrays, through `SmBrepData::FromBrep`. Every edgeuse on a face+/// without a UV trim first gets SMLib's own (`GetOrCreateUVTrimCurve`); edges and wire edges,+/// vertices and point-shell vertices, edgeuses and wire edgeuses are split apart, every index+/// compacted for the split.+fn flat_from_brep(k: &mut Kernel, b: &mut Brep) -> Result<Arrays> {+ for eu in solidcore::topology::brep::p2::edgeuses(b, None).map_err(sc("GetEdgeuses"))? {+ if eu1::faceuse(b, eu).map_err(sc("GetFaceuse"))?.is_none()+ || eu1::uv_trim_curve_pointer(b, eu).map_err(sc("GetUVTrimCurvePointer"))?.is_some()+ {+ continue;+ }+ let made = eu3::get_or_create_uv_trim_curve(k, b, eu, false, false, true).map_err(sc("GetOrCreateUVTrimCurve"))?;+ made.status.map_err(sc("GetOrCreateUVTrimCurve"))?;+ }+ let b: &Brep = b;++ // the BrepData; its records keep the B-rep's lists' order+ let store = AttributeStore::default();+ let records = NotifyRecords::new();+ let env = FromBrepEnv {+ attributes: &store,+ key_of: &key_of,+ records: &records,+ curve_key: &|_: EdgeId| ObjectKey(0),+ uv_curve_key: &|_: EdgeuseId| ObjectKey(0),+ surface_key: &|_: FaceId| ObjectKey(0),+ };+ let bd = BrepData::from_brep(b, &env, &mut Vec::new()).map_err(sc("SmBrepData::FromBrep"))?;+ let shell_ids = shells_in_order(b)?;+ let face_ids = bl::faces(b, None).map_err(sc("GetFaces"))?;+ let edge_ids = bl::edges(b, None).map_err(sc("GetEdges"))?;+ let vertex_ids = bl::vertices(b, None).map_err(sc("GetVertices"))?;+ if shell_ids.len() != bd.shells.len()+ || face_ids.len() != bd.faces.len()+ || edge_ids.len() != bd.edges.len()+ || vertex_ids.len() != bd.vertices.len()+ {+ return Err(bad("SmBrepData::FromBrep's lists differ from the B-rep's"));+ }++ // TOLERANCE is the B-rep's own tolerance, and each edge and vertex carries its own+ // (EDGE_TOLERANCE, VERTEX_TOLERANCE). Writing the largest one there instead, as SMLib's+ // `FlatFromBrep` does, makes it every entity's on import (MakeTopologyFromData raises each+ // entity to the B-rep's), so every crossing between the kernels spread the largest tolerance+ // over the body. Curves are still approximated to the largest.+ let zone = max_zone_tol(b)?;+ let brep_tol = b.tolerance();+ let xsect = 2.0 * if brep_tol.is_finite() && brep_tol > 0.0 && brep_tol < zone { brep_tol } else { zone };+ let approx_tol = zone / 2.0;+ let bbox = calculate_bounding_box(k, b, BoundingBoxOptions { approx: false, tight: false, expand_by_zone_tol_3d: false })+ .map_err(sc("CalculateBoundingBox"))?;++ let mut o = Out::new();+ o.r(TOLERANCE).push(xsect);+ let (lo, hi) = (bbox.min(), bbox.max());+ o.r(EXTENT).extend([lo.x, lo.y, lo.z, hi.x, hi.y, hi.z]);+ o.i(SOURCE).push(1);++ let edge_index: HashMap<EdgeId, usize> = edge_ids.iter().enumerate().map(|(i, &e)| (e, i)).collect();+ let edge_curve = |i: usize| -> Result<Option<&Curve>> { edge::curve(b, get(&edge_ids, i)?).map_err(sc("SmEdge::GetCurve")) };+ let mut exports = Vec::with_capacity(bd.edges.len());+ for (i, ed) in bd.edges.iter().enumerate() {+ exports.push(classify_edge_curve(k, edge_curve(i)?, &ed.interval)?);+ }++ // Regions+ for r in &bd.regions {+ o.i(REGION_SHELL_COUNT).push(i64::try_from(r.num_shells).map_err(|_| bad("count"))?);+ o.i(REGION_TYPE).push(i64::from(r.is_void != 0));+ }++ // Shells, wire edges and their curves, point-shell points+ let mut point_shell_vertices: Vec<u64> = Vec::new();+ let mut wire_edges: Vec<u64> = Vec::new();+ let mut wire_vertices_raw: Vec<u64> = Vec::new();+ for (sd, &s) in bd.shells.iter().zip(&shell_ids) {+ let sh = b.shell(s).map_err(sc("GetShell"))?;+ let faceuses = sh.get_faceuses().map_err(sc("SmShell::GetFaceuses"))?.len();+ let wires = shell::wire_edges(k, b, s).map_err(sc("SmShell::GetWireEdges"))?;+ let point = faceuses == 0 && wires.is_empty();+ o.i(SHELL_FACEUSE_COUNT).push(count(faceuses)?);+ o.i(SHELL_WIRE_EDGE_COUNT).push(count(wires.len())?);+ o.i(SHELL_POINT_TYPE).push(i64::from(point));+ for w in wires {+ let i = *edge_index.get(&w).ok_or_else(|| bad("a wire edge not in the B-rep"))?;+ let wd = bd.edges.get(i).ok_or_else(|| bad("wire edge record"))?;+ wire_edges.push(i as u64);+ wire_vertices_raw.extend([wd.start_vertex, wd.end_vertex]);+ write_edge_curve(k, &mut o, &WIRE_EDGES, &get(&exports, i)?, edge_curve(i)?, &wd.interval, approx_tol)?;+ }+ if point {+ let v = sh.vertex(b).map_err(sc("SmShell::GetVertex"))?.ok_or_else(|| bad("a point shell without its vertex"))?;+ point_shell_vertices.push(sd.vertex);+ let p = vertex::point(b, v).map_err(sc("SmVertex::GetPoint"))?;+ o.r3(SHELL_POINT_POSITION, p);+ }+ }+ point_shell_vertices.sort_unstable();+ wire_edges.sort_unstable();+ for v in wire_vertices_raw {+ let c = compact_index(v, &point_shell_vertices)?;+ o.i(WIRE_EDGE_VERTICES).push(c);+ }++ // Faceuses+ for fu in &bd.faceuses {+ o.i(FACEUSE_FACE).push(i64::try_from(fu.face).map_err(|_| bad("faceuse face"))?);+ o.i(FACEUSE_ORIENTATION).push(i64::from(fu.orientation == 1));+ }++ // Faces and their surfaces+ let n_loops = bd.loops.len();+ let mut loop_exports_uv = vec![false; n_loops];+ let mut loop_plane_map: Vec<Option<[f64; 6]>> = vec![None; n_loops];+ for (fd, &f) in bd.faces.iter().zip(&face_ids) {+ let surface = b.face(f).map_err(sc("GetFace"))?.surface.as_ref().ok_or_else(|| bad("a face without a surface"))?;+ // `m_lSurface >= m_vSurfaces.GetSize()`: a surface no face of the B-rep owns.+ if !usize::try_from(fd.surface).is_ok_and(|s| s < bd.surfaces.len()) {+ return Err(bad("a face whose surface its B-rep does not hold"));+ }+ let trim_type = i64::from(fd.rectangular_trim == 1);+ let ty = match surface.kind() {+ SurfaceKind::Sphere(_) => SURFACE_SPHERE_I,+ SurfaceKind::Plane(_) => SURFACE_PLANE_I,+ SurfaceKind::Cone(c) if c.is_cylinder_class() => SURFACE_CYLINDER_I,+ SurfaceKind::Cone(_) => SURFACE_CONE_I,+ SurfaceKind::Torus(_) => SURFACE_TORUS_I,+ _ => SURFACE_NURBS_I,+ };+ // A curved analytic face goes with its NURBS form, whose parameters its range and trims+ // are in; a plane's (u, v) are distances along its unit axes, an affine image of its+ // NURBS (u, v).+ let nurbs_form = ty != SURFACE_NURBS_I && ty != SURFACE_PLANE_I;+ let mut plane_map = None;+ if let SurfaceKind::Plane(p) = surface.kind() {+ let scale = p.uv_scale();+ let mut q = [Point2::new(0.0, 0.0); 3];+ let mut ok = true;+ for (qk, at) in q.iter_mut().zip([Point2::new(0.0, 0.0), Point2::new(1.0, 0.0), Point2::new(0.0, 1.0)]) {+ match answer(surface.convert_uv_from_nurbs_to_step(k, at)).map_err(sc("SmSurface::ConvertUVFromNURBSToSTEP"))? {+ Some(st) => *qk = Point2::new(st.x * scale.x, st.y * scale.y),+ None => {+ ok = false;+ break;+ }+ }+ }+ if ok {+ let [q0, q1, q2] = q;+ plane_map = Some([q0.x, q1.x - q0.x, q2.x - q0.x, q0.y, q1.y - q0.y, q2.y - q0.y]);+ }+ }+ for l in 0..fd.num_loops {+ let li = index_u64(fd.start_loop.saturating_add(l))?;+ let (Some(x), Some(m)) = (loop_exports_uv.get_mut(li), loop_plane_map.get_mut(li)) else {+ return Err(bad("face loop index is out of bounds"));+ };+ *x = ty == SURFACE_NURBS_I || nurbs_form || plane_map.is_some();+ *m = plane_map;+ }++ // face range: a NURBS (or NURBS form) face's native (u, v); an analytic surface's STEP+ // domain, angles in radians+ let d = fd.uv_domain;+ let (mut umin, mut vmin, mut umax, mut vmax) = (d.u_min(), d.v_min(), d.u_max(), d.v_max());+ if ty != SURFACE_NURBS_I && !nurbs_form {+ let step = surface.step_uv_domain();+ if ty == SURFACE_SPHERE_I || ty == SURFACE_TORUS_I {+ (umin, vmin, umax, vmax) = (deg2rad(step.u_min()), deg2rad(step.v_min()), deg2rad(step.u_max()), deg2rad(step.v_max()));+ } else if ty == SURFACE_CYLINDER_I || ty == SURFACE_CONE_I {+ (umin, vmin, umax, vmax) = (deg2rad(step.u_min()), step.v_min(), deg2rad(step.u_max()), step.v_max());+ } else if let SurfaceKind::Plane(p) = surface.kind() {+ // plane parameters are distances along unit placement axes (SmExtent2d::Scale)+ let s = p.uv_scale();+ let scale = |x: f64, by: f64| if is_infinite(x) { x } else { x * by };+ (umin, vmin, umax, vmax) = (scale(step.u_min(), s.x), scale(step.v_min(), s.y), scale(step.u_max(), s.x), scale(step.v_max(), s.y));+ }+ }+ o.i(FACE_LOOP_COUNT).push(i64::try_from(fd.num_loops).map_err(|_| bad("count"))?);+ o.i(FACE_SURFACE_TYPE).push(ty);+ o.i(FACE_TRIM_TYPE).push(trim_type);+ o.i(FACE_NURBS_FORM).push(i64::from(nurbs_form));+ o.r(FACE_RANGE).extend([umin, vmin, umax, vmax]);++ match surface.kind() {+ SurfaceKind::Sphere(s) => {+ let pos = s.base().position();+ o.r3(FACE_SPHERE_CENTER, pos.origin());+ o.r3(FACE_SPHERE_AXIS, pos.z_axis());+ o.r3(FACE_SPHERE_REF_DIRECTION, pos.x_axis());+ o.r(FACE_SPHERE_RADIUS).push(s.radius());+ }+ SurfaceKind::Plane(p) => {+ let pos = p.position();+ o.r3(FACE_PLANE_ORIGIN, pos.origin());+ o.r3(FACE_PLANE_AXIS, pos.z_axis());+ o.r3(FACE_PLANE_REF_DIRECTION, pos.x_axis());+ }+ SurfaceKind::Cone(c) if c.is_cylinder_class() => {+ let pos = c.canonical().origin;+ o.r3(FACE_CYLINDER_ORIGIN, pos.origin());+ o.r3(FACE_CYLINDER_AXIS, pos.z_axis());+ o.r3(FACE_CYLINDER_REF_DIRECTION, pos.x_axis());+ o.r(FACE_CYLINDER_RADIUS).push(c.bot_radius());+ }+ SurfaceKind::Cone(c) => {+ let can = c.canonical();+ o.r3(FACE_CONE_ORIGIN, can.origin.origin());+ o.r3(FACE_CONE_AXIS, can.origin.z_axis());+ o.r3(FACE_CONE_REF_DIRECTION, can.origin.x_axis());+ o.r(FACE_CONE_RADIUS).push(can.radius);+ o.r(FACE_CONE_SEMI_ANGLE).push(deg2rad(can.semi_angle_deg));+ }+ SurfaceKind::Torus(t) => {+ let pos = t.base().position();+ o.r3(FACE_TORUS_ORIGIN, pos.origin());+ o.r3(FACE_TORUS_AXIS, pos.z_axis());+ o.r3(FACE_TORUS_REF_DIRECTION, pos.x_axis());+ o.r(FACE_TORUS_MAJOR_RADIUS).push(t.major_radius());+ o.r(FACE_TORUS_MINOR_RADIUS).push(t.minor_radius());+ }+ _ => {}+ }+ if nurbs_form || ty == SURFACE_NURBS_I {+ // Every analytic class is an SmBSplineSurface: its own NURBS, in face order with the+ // NURBS faces' surfaces. Another surface (an offset) is approximated within the+ // curves' tolerance, splitting its spans up to 5 times; its status fails the export,+ // as does no surface, which would leave the arrays without this face's NURBS.+ let approximated;+ let part = match bspline_surface_part(k, surface)? {+ Some(part) => part,+ None => {+ approximated = surface+ .approximate_surface(k, approx_tol3d(k, approx_tol), 5, true)+ .map_err(sc("SmSurface::ApproximateSurface"))?+ .surface+ .ok_or_else(|| bad("a face surface SMLib could not convert to a B-spline"))?;+ bspline_surface_part(k, &approximated)?.ok_or_else(|| bad("an approximated face surface that is not a B-spline"))?+ }+ };+ add_bspline_surface(&mut o, part.gw_nurb().ok_or_else(|| bad("a B-spline surface without its NURB"))?)?;+ }+ }++ // Loops+ for l in &bd.loops {+ if l.loop_type == 0 && l.num_eu > 0 {+ o.i(LOOP_EDGEUSE_COUNT).push(i64::try_from(l.num_eu).map_err(|_| bad("count"))?);+ o.i(LOOP_VERTEX).push(-1);+ } else if l.loop_type == 1 && l.vertex != NO_OBJECT && l.vertex != UNDEF_ULONG {+ o.i(LOOP_EDGEUSE_COUNT).push(0);+ let c = compact_index(l.vertex, &point_shell_vertices)?;+ o.i(LOOP_VERTEX).push(c);+ } else {+ return Err(bad("incorrect loop type"));+ }+ }++ // Edgeuses connecting edges to faces; wire edges' edgeuses are removed. A pair's radial+ // entry: 1 when its top edgeuse's next is its own bottom one.+ let non_face: Vec<u64> = bd.edgeuses.iter().enumerate().filter(|(_, e)| e.eu_type != 0).map(|(i, _)| i as u64).collect();+ for (j, eu) in bd.edgeuses.iter().enumerate() {+ if eu.eu_type != 0 {+ continue;+ }+ let j = count(j)?;+ o.i(EDGEUSE_EDGE).push(compact_index(eu.edge, &wire_edges)?);+ o.i(EDGEUSE_ORIENTATION).push(i64::from(eu.orientation == 1));+ let top_next = if eu.next_eu >= 0 { eu.next_eu } else { -eu.next_eu - 1 };+ let bot_next = if eu.mate_next_eu >= 0 { eu.mate_next_eu } else { -eu.mate_next_eu - 1 };+ let top_entry = top_next == j;+ o.i(EDGEUSE_RADIAL_ENTRY).push(i64::from(top_entry));+ let next = u64::try_from(if top_entry { bot_next } else { top_next }).map_err(|_| bad("radial index"))?;+ let next = compact_index(next, &non_face)?;+ o.i(EDGEUSE_NEXT_RADIAL).push(next);++ // the UV trim, on faces whose loops carry them+ let li = index_u64(eu.loop_)?;+ let exports_uv = *loop_exports_uv.get(li).ok_or_else(|| bad("edgeuse loop index is out of bounds"))?;+ let trim = if exports_uv && eu.uv_curve != NO_OBJECT { bd.uv_curves.get(index_u64(eu.uv_curve)?) } else { None };+ let part = match trim {+ Some(t) => bspline_curve_part(k, &t.object)?,+ None => None,+ };+ let mut nurb = part.as_deref().map(nurb_of).transpose()?;+ // On an edge exported as a line, the trim's knots follow the line's parameter, or the+ // trim is dropped where that is not an affine image of the edge's (SMLib rebuilds it).+ // Circles and ellipses go out on their NURBS form, whose parameter the trims are in.+ let mut remap = None;+ let ei = index_u64(eu.edge)?;+ if nurb.is_some()+ && let Some(ex) = exports.get(ei)+ && ex.ty == CURVE_LINE_I+ {+ if ex.affine {+ let ivl = bd.edges.get(ei).ok_or_else(|| bad("edge record"))?.interval;+ remap = Some([ivl.min(), ivl.max(), ex.sm_lo, ex.sm_hi]);+ } else {+ nurb = None;+ }+ }+ let affine = loop_plane_map.get(li).copied().flatten();+ let before = o.i(EDGEUSE_NURBS_VERTEX_COUNT).len();+ if add_bspline_curve_2d(&mut o, nurb, eu.orientation == 1, remap, affine).is_err() && o.i(EDGEUSE_NURBS_VERTEX_COUNT).len() == before {+ // UV trims are optional: keep the edgeuse / trim records one to one+ o.i(EDGEUSE_NURBS_VERTEX_COUNT).push(0);+ o.i(EDGEUSE_NURBS_ORDER).push(0);+ }+ }++ // Edges (face edges; wire edges went with their shells)+ for (j, ed) in bd.edges.iter().enumerate() {+ if wire_edges.binary_search(&(j as u64)).is_ok() {+ continue;+ }+ let e = get(&edge_ids, j)?;+ let start = compact_index(ed.start_vertex, &point_shell_vertices)?;+ let end = compact_index(ed.end_vertex, &point_shell_vertices)?;+ o.i(EDGE_VERTICES).extend([start, end]);+ let faces = edge::faces(b, e, None).map_err(sc("SmEdge::GetFaces"))?;+ let own = edge::tolerance(b, e).map_err(sc("SmEdge::GetTolerance"))?;+ o.r(EDGE_TOLERANCE).push(2.0 * zone_tol_with_faces(b, own, brep_tol, &faces)?);+ write_edge_curve(k, &mut o, &EDGES, &get(&exports, j)?, edge_curve(j)?, &ed.interval, approx_tol)?;+ }++ // Vertices (point-shell vertices went with their shells)+ for (j, vd) in bd.vertices.iter().enumerate() {+ if point_shell_vertices.binary_search(&(j as u64)).is_ok() {+ continue;+ }+ o.i(VERTEX_POINT_TYPE).push(1);+ o.r3(VERTEX_POSITION, vd.point);+ let v: VertexId = get(&vertex_ids, j)?;+ let faces = vertex::faces(b, v).map_err(sc("SmVertex::GetFaces"))?;+ let own = vertex::tolerance(b, v).map_err(sc("SmVertex::GetTolerance"))?;+ o.r(VERTEX_TOLERANCE).push(2.0 * zone_tol_with_faces(b, own, brep_tol, &faces)?);+ }+ Ok(o.0)+}++// ---- import: Validate --------------------------------------------------------------------------++/// The arrays of one B-rep, read as hostile input.+struct In<'a>(&'a Arrays);++impl<'a> In<'a> {+ fn i(&self, id: i32) -> &'a [i64] {+ self.0.ints.get(&id).map_or(&[], Vec::as_slice)+ }+ fn r(&self, id: i32) -> &'a [f64] {+ self.0.reals.get(&id).map_or(&[], Vec::as_slice)+ }+}++/// What `Validate` learns about valid input (`Shape`).+#[derive(Default)]+struct Shape {+ regions: usize,+ shells: usize,+ faceuses: usize,+ faces: usize,+ loops: usize,+ edgeuses: usize,+ edges: usize,+ wire_edges: usize,+ vertices: usize,+ point_shells: usize,+ uv_curves: bool,+}++/// Below SMLib's index sentinels (`SM_NO_OBJECT`, `MakeTopologyFromData`'s 999999).+const MAX_TOPOLOGY: i64 = 999_000;+/// `NL_MAXDEG + 1`.+const MAX_ORDER: i64 = 18;+const MAX_VALUE: f64 = 1.0e9;+const MAX_FLAT_LEN: i64 = 1 << 27;++fn bits(v: &[i64]) -> bool {+ v.iter().all(|&x| x == 0 || x == 1)+}++fn in_range(v: &[i64], lo: i64, hi: i64) -> bool {+ v.iter().all(|&x| x >= lo && x <= hi)+}++/// `SumCounts`: the sum of non-negative counts, `None` past [`MAX_TOPOLOGY`].+fn sum_counts(v: &[i64]) -> Option<i64> {+ let mut s = 0i64;+ for &x in v {+ if !(0..=MAX_TOPOLOGY).contains(&x) {+ return None;+ }+ s += x;+ if s > MAX_TOPOLOGY {+ return None;+ }+ }+ Some(s)+}++fn has_form(form: &[i64], i: usize) -> bool {+ form.get(i) == Some(&1)+}++/// `GoodFrame`: an axis and a reference direction that span a plane.+fn good_frame(axis: &[f64], refd: &[f64], i: usize) -> bool {+ let (Ok(a), Ok(r)) = (get3(axis, i), get3(refd, i)) else { return false };+ let (la, lr) = (a.length(), r.length());+ la > 1e-12 && lr > 1e-12 && a.cross(r).length() > 1e-9 * la * lr+}++/// `GoodKnots`: `count + order` knots, non-decreasing, with a non-empty interval.+fn good_knots(k: &[f64], count: i64, order: i64) -> bool {+ let (Ok(n), Ok(o)) = (usize::try_from(count), usize::try_from(order)) else { return false };+ let Some(k) = n.checked_add(o).and_then(|m| k.get(..m)) else { return false };+ if !k.windows(2).all(|w| matches!(w, [a, b] if b >= a)) {+ return false;+ }+ matches!((o.checked_sub(1).and_then(|i| k.get(i)), k.get(n)), (Some(a), Some(b)) if a < b)+}++fn good_weights(w: &[f64]) -> bool {+ w.iter().all(|&x| x > 0.0)+}++/// `GoodNurbsCurves`: one family of NURBS curves; with `optional`, a curve of count and order 0+/// is none.+fn good_nurbs_curves(count: &[i64], order: &[i64], cvs: &[f64], knots: &[f64], weights: &[f64], dim: i64, optional: bool) -> bool {+ if count.len() != order.len() {+ return false;+ }+ let (mut points, mut knot_total) = (0i64, 0i64);+ for (&c, &o) in count.iter().zip(order) {+ if optional && c == 0 && o == 0 {+ continue;+ }+ if !(2..=MAX_ORDER).contains(&o) || c < o || c > MAX_FLAT_LEN {+ return false;+ }+ points += c;+ knot_total += c + o;+ if points > MAX_FLAT_LEN || knot_total > MAX_FLAT_LEN {+ return false;+ }+ }+ if i64::try_from(cvs.len()).ok() != Some(dim * points) || i64::try_from(knots.len()).ok() != Some(knot_total) {+ return false;+ }+ if !weights.is_empty() && (i64::try_from(weights.len()).ok() != Some(points) || !good_weights(weights)) {+ return false;+ }+ let mut k = 0usize;+ for (&c, &o) in count.iter().zip(order) {+ if optional && c == 0 {+ continue;+ }+ if !knots.get(k..).is_some_and(|s| good_knots(s, c, o)) {+ return false;+ }+ k += (c + o) as usize;+ }+ true+}++/// One edge family's arrays (`GoodEdges`, `MakeEdgeCurve`).+struct EdgeIn<'a> {+ ty: &'a [i64],+ vertices: &'a [i64],+ range: &'a [f64],+ count: &'a [i64],+ order: &'a [i64],+ cvs: &'a [f64],+ knots: &'a [f64],+ weights: &'a [f64],+ circle_center: &'a [f64],+ circle_axis: &'a [f64],+ circle_ref: &'a [f64],+ circle_radius: &'a [f64],+ line_origin: &'a [f64],+ line_direction: &'a [f64],+ ellipse_center: &'a [f64],+ ellipse_axis: &'a [f64],+ ellipse_ref: &'a [f64],+ ellipse_x: &'a [f64],+ ellipse_y: &'a [f64],+ form: &'a [i64],+}++impl<'a> EdgeIn<'a> {+ fn new(f: &In<'a>, ids: &EdgeIds) -> EdgeIn<'a> {+ EdgeIn {+ ty: f.i(ids.ty),+ vertices: f.i(ids.vertices),+ range: f.r(ids.range),+ count: f.i(ids.count),+ order: f.i(ids.order),+ cvs: f.r(ids.cvs),+ knots: f.r(ids.knots),+ weights: f.r(ids.weights),+ circle_center: f.r(ids.circle_center),+ circle_axis: f.r(ids.circle_axis),+ circle_ref: f.r(ids.circle_ref),+ circle_radius: f.r(ids.circle_radius),+ line_origin: f.r(ids.line_origin),+ line_direction: f.r(ids.line_direction),+ ellipse_center: f.r(ids.ellipse_center),+ ellipse_axis: f.r(ids.ellipse_axis),+ ellipse_ref: f.r(ids.ellipse_ref),+ ellipse_x: f.r(ids.ellipse_x),+ ellipse_y: f.r(ids.ellipse_y),+ form: f.i(ids.form),+ }+ }+}++/// `GoodEdges`: an edge family's ranges against its curves.+fn good_edges(e: &EdgeIn<'_>, n: usize, n_vertices: usize) -> bool {+ // a NURBS form is given for circles and ellipses only, one flag per edge, or for none+ if !e.form.is_empty() && (e.form.len() != n || !bits(e.form)) {+ return false;+ }+ if e.form.iter().zip(e.ty).any(|(&f, &t)| f == 1 && t != CURVE_CIRCLE_I && t != CURVE_ELLIPSE_I) {+ return false;+ }+ let Ok(last_vertex) = i64::try_from(n_vertices).map(|v| v - 1) else { return false };+ if e.ty.len() != n+ || Some(e.vertices.len()) != n.checked_mul(2)+ || Some(e.range.len()) != n.checked_mul(2)+ || !in_range(e.ty, CURVE_NURBS_I, CURVE_ELLIPSE_I)+ || !in_range(e.vertices, 0, last_vertex)+ {+ return false;+ }+ let (mut n_n, mut n_c, mut n_l, mut n_e) = (0usize, 0usize, 0usize, 0usize);+ for (i, &t) in e.ty.iter().enumerate() {+ n_n += usize::from(t == CURVE_NURBS_I || has_form(e.form, i));+ n_c += usize::from(t == CURVE_CIRCLE_I);+ n_l += usize::from(t == CURVE_LINE_I);+ n_e += usize::from(t == CURVE_ELLIPSE_I);+ }+ if e.count.len() != n_n || !good_nurbs_curves(e.count, e.order, e.cvs, e.knots, e.weights, 3, false) {+ return false;+ }+ if e.circle_center.len() != 3 * n_c+ || e.circle_axis.len() != 3 * n_c+ || e.circle_ref.len() != 3 * n_c+ || e.circle_radius.len() != n_c+ || e.line_origin.len() != 3 * n_l+ || e.line_direction.len() != 3 * n_l+ || e.ellipse_center.len() != 3 * n_e+ || e.ellipse_axis.len() != 3 * n_e+ || e.ellipse_ref.len() != 3 * n_e+ || e.ellipse_x.len() != n_e+ || e.ellipse_y.len() != n_e+ {+ return false;+ }+ for i in 0..n_c {+ if !(e.circle_radius.get(i).is_some_and(|&r| r > 0.0)) || !good_frame(e.circle_axis, e.circle_ref, i) {+ return false;+ }+ }+ for i in 0..n_l {+ if !get3(e.line_direction, i).is_ok_and(|d| d.length() > 1e-12) {+ return false;+ }+ }+ for i in 0..n_e {+ if !(e.ellipse_x.get(i).is_some_and(|&r| r > 0.0) && e.ellipse_y.get(i).is_some_and(|&r| r > 0.0))+ || !good_frame(e.ellipse_axis, e.ellipse_ref, i)+ {+ return false;+ }+ }+ // each edge's range: non-empty; inside its NURBS curve's knot interval; at most one turn+ // for circles and ellipses (radians)+ let (mut i_nurbs, mut knot) = (0usize, 0usize);+ for i in 0..n {+ let (Some(&lo), Some(&hi)) = (e.range.get(2 * i), e.range.get(2 * i + 1)) else { return false };+ let t = e.ty.get(i).copied().unwrap_or(-1);+ if !(lo < hi) {+ return false;+ }+ if t == CURVE_NURBS_I || has_form(e.form, i) {+ let (Some(&c), Some(&o)) = (e.count.get(i_nurbs), e.order.get(i_nurbs)) else { return false };+ let (Ok(cu), Ok(ou)) = (usize::try_from(c), usize::try_from(o)) else { return false };+ let (Some(&k0), Some(&k1)) = (e.knots.get(knot + ou - 1), e.knots.get(knot + cu)) else { return false };+ let tol = 1e-9 * (k1 - k0).max(1.0);+ if lo < k0 - tol || hi > k1 + tol {+ return false;+ }+ knot += cu + ou;+ i_nurbs += 1;+ } else if (t == CURVE_CIRCLE_I || t == CURVE_ELLIPSE_I)+ && (hi - lo > std::f64::consts::TAU + 1e-9+ || lo.abs() > std::f64::consts::TAU * (1.0 + 1e-9)+ || hi.abs() > std::f64::consts::TAU * (1.0 + 1e-9))+ {+ return false; // SmCircle/SmEllipse::CreateCanonical take [-360, 360] degrees+ } else if t == CURVE_LINE_I && (lo.abs() > INFINITE_PARAMETER || hi.abs() > INFINITE_PARAMETER) {+ return false; // an imported line is unbounded over +-SM_INFINITE_PARAMETER+ }+ }+ true+}++fn face_has_nurbs(f: &In<'_>, i: usize) -> bool {+ f.i(FACE_SURFACE_TYPE).get(i) == Some(&SURFACE_NURBS_I) || has_form(f.i(FACE_NURBS_FORM), i)+}++/// `Validate`: every check the build relies on; `None` on anything malformed.+fn validate(f: &In<'_>) -> Option<Shape> {+ let mut s = Shape::default();+ // every double is finite and of sane magnitude+ if f.0.reals.values().flatten().any(|x| !x.is_finite() || x.abs() > MAX_VALUE) {+ return None;+ }++ // B-rep data+ let tol = f.r(TOLERANCE);+ if tol.len() != 1 || !tol.iter().all(|&t| t > 0.0 && t <= 1.0) {+ return None;+ }+ if !f.r(EXTENT).is_empty() && f.r(EXTENT).len() != 6 {+ return None;+ }+ if f.i(SOURCE).len() > 1 || !bits(f.i(SOURCE)) {+ return None;+ }++ // Regions+ s.regions = f.i(REGION_SHELL_COUNT).len();+ let shells = sum_counts(f.i(REGION_SHELL_COUNT))?;+ if s.regions < 1 || s.regions > MAX_TOPOLOGY as usize || f.i(REGION_TYPE).len() != s.regions || !bits(f.i(REGION_TYPE)) {+ return None;+ }+ s.shells = shells as usize;++ // Shells: a faceuse shell, a wire-edge shell (one edge) or a point shell+ let (fu_count, we_count, pt_type) = (f.i(SHELL_FACEUSE_COUNT), f.i(SHELL_WIRE_EDGE_COUNT), f.i(SHELL_POINT_TYPE));+ if fu_count.len() != s.shells || we_count.len() != s.shells || pt_type.len() != s.shells || !bits(we_count) || !bits(pt_type) {+ return None;+ }+ let faceuses = sum_counts(fu_count)?;+ if faceuses % 2 != 0 {+ return None;+ }+ for i in 0..s.shells {+ let (fu, we, pt) = (fu_count.get(i)?, we_count.get(i)?, pt_type.get(i)?);+ if *fu > 0 {+ if *we != 0 {+ return None;+ }+ } else if *we == 0 {+ if *pt != 1 {+ return None;+ }+ s.point_shells += 1;+ }+ }+ s.wire_edges = sum_counts(we_count)? as usize;+ if f.r(SHELL_POINT_POSITION).len() != 3 * s.point_shells {+ return None;+ }++ // Faceuses: each face has exactly two, one on each side+ s.faceuses = faceuses as usize;+ s.faces = s.faceuses / 2;+ let (fu_face, fu_orient) = (f.i(FACEUSE_FACE), f.i(FACEUSE_ORIENTATION));+ if fu_face.len() != s.faceuses || fu_orient.len() != s.faceuses || !bits(fu_orient) || !in_range(fu_face, 0, s.faces as i64 - 1) {+ return None;+ }+ let mut sides = vec![0u8; s.faces];+ for (&face, &o) in fu_face.iter().zip(fu_orient) {+ let bit = if o == 1 { 1 } else { 2 };+ let side = sides.get_mut(face as usize)?;+ if *side & bit != 0 {+ return None;+ }+ *side |= bit;+ }++ // Faces+ let (loop_count, surface_type, trim_type, range) = (f.i(FACE_LOOP_COUNT), f.i(FACE_SURFACE_TYPE), f.i(FACE_TRIM_TYPE), f.r(FACE_RANGE));+ if loop_count.len() != s.faces+ || surface_type.len() != s.faces+ || trim_type.len() != s.faces+ || range.len() != 4 * s.faces+ || !bits(trim_type)+ || !in_range(surface_type, SURFACE_NURBS_I, SURFACE_TORUS_I)+ || !in_range(loop_count, 1, MAX_TOPOLOGY)+ {+ return None;+ }+ let form = f.i(FACE_NURBS_FORM);+ if !form.is_empty() {+ if form.len() != s.faces || !bits(form) {+ return None;+ }+ if form.iter().zip(surface_type).any(|(&fm, &t)| fm == 1 && (t == SURFACE_NURBS_I || t == SURFACE_PLANE_I)) {+ return None;+ }+ }+ for i in 0..s.faces {+ let (u0, v0, u1, v1) = (*range.get(4 * i)?, *range.get(4 * i + 1)?, *range.get(4 * i + 2)?, *range.get(4 * i + 3)?);+ if !(u0 < u1) || !(v0 < v1) {+ return None;+ }+ // angular parameters (radians): at most one turn, near the principal range; a sphere's+ // latitude within [-pi/2, pi/2]. A face given with its NURBS form has a NURBS range.+ let t = if face_has_nurbs(f, i) { SURFACE_NURBS_I } else { *surface_type.get(i)? };+ let u_angle = t == SURFACE_SPHERE_I || t == SURFACE_TORUS_I || t == SURFACE_CYLINDER_I || t == SURFACE_CONE_I;+ let v_angle = t == SURFACE_SPHERE_I || t == SURFACE_TORUS_I;+ let pi = std::f64::consts::PI;+ let (turn, far) = (2.0 * pi * (1.0 + 1e-9), 4.0 * pi);+ if (u_angle && (u1 - u0 > turn || u0.abs() > far || u1.abs() > far))+ || (v_angle && (v1 - v0 > turn || v0.abs() > far || v1.abs() > far))+ || (t == SURFACE_SPHERE_I && (v0 < -0.5 * pi - 1e-9 || v1 > 0.5 * pi + 1e-9))+ {+ return None;+ }+ }+ s.loops = sum_counts(loop_count)? as usize;++ // Vertices+ s.vertices = f.i(VERTEX_POINT_TYPE).len();+ if s.vertices > MAX_TOPOLOGY as usize+ || s.vertices + s.point_shells > MAX_TOPOLOGY as usize+ || !in_range(f.i(VERTEX_POINT_TYPE), 1, 1)+ || f.r(VERTEX_POSITION).len() != 3 * s.vertices+ {+ return None;+ }+ // per-edge and per-vertex tolerances: none, or one each+ let tolerances_ok = |t: &[f64], n: usize| t.is_empty() || (t.len() == n && t.iter().all(|&x| x.is_finite() && x > 0.0 && x <= 1.0));+ if !tolerances_ok(f.r(VERTEX_TOLERANCE), s.vertices) {+ return None;+ }++ // Loops+ let (lp_count, lp_vertex) = (f.i(LOOP_EDGEUSE_COUNT), f.i(LOOP_VERTEX));+ if lp_count.len() != s.loops || lp_vertex.len() != s.loops {+ return None;+ }+ s.edgeuses = sum_counts(lp_count)? as usize;+ for (&n, &v) in lp_count.iter().zip(lp_vertex) {+ if if n == 0 { !(v >= 0 && v < s.vertices as i64) } else { v != -1 } {+ return None;+ }+ }++ // Edges and wire edges+ s.edges = f.i(EDGE_CURVE_TYPE).len();+ if s.edges > MAX_TOPOLOGY as usize || s.edges + s.wire_edges > MAX_TOPOLOGY as usize || s.wire_edges + s.edgeuses > MAX_TOPOLOGY as usize {+ return None;+ }+ if !tolerances_ok(f.r(EDGE_TOLERANCE), s.edges) {+ return None;+ }+ if !good_edges(&EdgeIn::new(f, &EDGES), s.edges, s.vertices) || !good_edges(&EdgeIn::new(f, &WIRE_EDGES), s.wire_edges, s.vertices) {+ return None;+ }++ // Edgeuses+ let (eu_edge, eu_orient, eu_next, eu_entry) = (f.i(EDGEUSE_EDGE), f.i(EDGEUSE_ORIENTATION), f.i(EDGEUSE_NEXT_RADIAL), f.i(EDGEUSE_RADIAL_ENTRY));+ if eu_edge.len() != s.edgeuses+ || eu_orient.len() != s.edgeuses+ || eu_next.len() != s.edgeuses+ || eu_entry.len() != s.edgeuses+ || !bits(eu_orient)+ || !bits(eu_entry)+ || !in_range(eu_edge, 0, s.edges as i64 - 1)+ || !in_range(eu_next, 0, s.edgeuses as i64 - 1)+ {+ return None;+ }+ {+ // the radial lists: NEXT_RADIAL is a permutation that stays on each edge and cycles once+ // through all of each edge's edgeuses; every edge has at least one edgeuse+ let mut per_edge = vec![0i64; s.edges];+ let mut hit = vec![false; s.edgeuses];+ let mut first = vec![-1i64; s.edges];+ for i in 0..s.edgeuses {+ let e = *eu_edge.get(i)? as usize;+ let n = *eu_next.get(i)? as usize;+ if eu_edge.get(n)? != eu_edge.get(i)? || *hit.get(n)? {+ return None;+ }+ *hit.get_mut(n)? = true;+ *per_edge.get_mut(e)? += 1;+ if *first.get(e)? < 0 {+ *first.get_mut(e)? = i as i64;+ }+ }+ for e in 0..s.edges {+ let start = *first.get(e)?;+ if start < 0 {+ return None;+ }+ let (mut steps, mut cur) = (0i64, start);+ loop {+ cur = *eu_next.get(cur as usize)?;+ steps += 1;+ if cur == start || steps > *per_edge.get(e)? {+ break;+ }+ }+ if steps != *per_edge.get(e)? {+ return None;+ }+ }+ }++ // every vertex is used; every edgeuse loop is a closed chain of its edges' vertices+ {+ let ev = f.i(EDGE_VERTICES);+ let mut used = vec![false; s.vertices];+ for &v in ev.iter().chain(f.i(WIRE_EDGE_VERTICES)) {+ *used.get_mut(v as usize)? = true;+ }+ let mut eu = 0usize;+ for l in 0..s.loops {+ let n = *lp_count.get(l)? as usize;+ if n == 0 {+ *used.get_mut(*lp_vertex.get(l)? as usize)? = true;+ continue;+ }+ for k in 0..n {+ let (a, b) = (eu + k, eu + (k + 1) % n);+ let (ea, eb) = (*eu_edge.get(a)? as usize, *eu_edge.get(b)? as usize);+ let end_a = ev.get(2 * ea + usize::from(*eu_orient.get(a)? == 1))?;+ let start_b = ev.get(2 * eb + usize::from(*eu_orient.get(b)? != 1))?;+ if end_a != start_b {+ return None;+ }+ }+ eu += n;+ }+ if !used.iter().all(|&u| u) {+ return None;+ }+ }++ // UV trim curves: none, or one record per edgeuse+ let (uv_count, uv_order) = (f.i(EDGEUSE_NURBS_VERTEX_COUNT), f.i(EDGEUSE_NURBS_ORDER));+ if uv_count.len() != uv_order.len() || (!uv_count.is_empty() && uv_count.len() != s.edgeuses) {+ return None;+ }+ s.uv_curves = !uv_count.is_empty();+ if uv_count.iter().zip(uv_order).any(|(&c, &o)| (c == 0) != (o == 0)) {+ return None;+ }+ if !good_nurbs_curves(uv_count, uv_order, f.r(EDGEUSE_NURBS_CVS), f.r(EDGEUSE_NURBS_KNOTS), f.r(EDGEUSE_NURBS_WEIGHTS), 2, true) {+ return None;+ }++ // Surfaces+ let mut n_t = [0usize; 6];+ for &t in surface_type {+ *n_t.get_mut(t as usize)? += 1;+ }+ let n_n = (0..s.faces).filter(|&i| face_has_nurbs(f, i)).count();+ let [_, n_p, n_cy, n_co, n_s, n_to] = n_t;+ let (cu_v, cv_v, ou_v, ov_v) = (f.i(FACE_NURBS_U_VERTEX_COUNT), f.i(FACE_NURBS_V_VERTEX_COUNT), f.i(FACE_NURBS_U_ORDER), f.i(FACE_NURBS_V_ORDER));+ if cu_v.len() != n_n || cv_v.len() != n_n || ou_v.len() != n_n || ov_v.len() != n_n {+ return None;+ }+ {+ let (uks, vks) = (f.r(FACE_NURBS_U_KNOTS), f.r(FACE_NURBS_V_KNOTS));+ let (mut points, mut uk, mut vk) = (0i64, 0i64, 0i64);+ for i in 0..n_n {+ let (cu, cv, ou, ov) = (*cu_v.get(i)?, *cv_v.get(i)?, *ou_v.get(i)?, *ov_v.get(i)?);+ if !(2..=MAX_ORDER).contains(&ou)+ || !(2..=MAX_ORDER).contains(&ov)+ || cu < ou+ || cv < ov+ || cu > MAX_FLAT_LEN+ || cv > MAX_FLAT_LEN+ || cu * cv > MAX_FLAT_LEN+ {+ return None;+ }+ points += cu * cv;+ uk += cu + ou;+ vk += cv + ov;+ if points > MAX_FLAT_LEN || uk > MAX_FLAT_LEN || vk > MAX_FLAT_LEN {+ return None;+ }+ }+ if f.r(FACE_NURBS_CVS).len() as i64 != 3 * points || uks.len() as i64 != uk || vks.len() as i64 != vk {+ return None;+ }+ let w = f.r(FACE_NURBS_WEIGHTS);+ if !w.is_empty() && (w.len() as i64 != points || !good_weights(w)) {+ return None;+ }+ let (mut uk, mut vk) = (0usize, 0usize);+ for i in 0..n_n {+ let (cu, cv, ou, ov) = (*cu_v.get(i)?, *cv_v.get(i)?, *ou_v.get(i)?, *ov_v.get(i)?);+ if !good_knots(uks.get(uk..)?, cu, ou) || !good_knots(vks.get(vk..)?, cv, ov) {+ return None;+ }+ uk += (cu + ou) as usize;+ vk += (cv + ov) as usize;+ }+ // each NURBS face's range overlaps its surface's knot domain (MakeTopologyFromData+ // intersects the two)+ let (mut i_n, mut uk, mut vk) = (0usize, 0usize, 0usize);+ for i in 0..s.faces {+ if !face_has_nurbs(f, i) {+ continue;+ }+ let (cu, cv, ou, ov) = (*cu_v.get(i_n)? as usize, *cv_v.get(i_n)? as usize, *ou_v.get(i_n)? as usize, *ov_v.get(i_n)? as usize);+ let (u_lo, u_hi) = (*uks.get(uk + ou - 1)?, *uks.get(uk + cu)?);+ let (v_lo, v_hi) = (*vks.get(vk + ov - 1)?, *vks.get(vk + cv)?);+ if !(range.get(4 * i + 2)?.min(u_hi) > range.get(4 * i)?.max(u_lo))+ || !(range.get(4 * i + 3)?.min(v_hi) > range.get(4 * i + 1)?.max(v_lo))+ {+ return None;+ }+ uk += cu + ou;+ vk += cv + ov;+ i_n += 1;+ }+ }+ let lens = |id: i32, n: usize| f.r(id).len() == n;+ if !(lens(FACE_PLANE_ORIGIN, 3 * n_p)+ && lens(FACE_PLANE_AXIS, 3 * n_p)+ && lens(FACE_PLANE_REF_DIRECTION, 3 * n_p)+ && lens(FACE_CYLINDER_ORIGIN, 3 * n_cy)+ && lens(FACE_CYLINDER_AXIS, 3 * n_cy)+ && lens(FACE_CYLINDER_REF_DIRECTION, 3 * n_cy)+ && lens(FACE_CYLINDER_RADIUS, n_cy)+ && lens(FACE_CONE_ORIGIN, 3 * n_co)+ && lens(FACE_CONE_AXIS, 3 * n_co)+ && lens(FACE_CONE_REF_DIRECTION, 3 * n_co)+ && lens(FACE_CONE_RADIUS, n_co)+ && lens(FACE_CONE_SEMI_ANGLE, n_co)+ && lens(FACE_SPHERE_CENTER, 3 * n_s)+ && lens(FACE_SPHERE_AXIS, 3 * n_s)+ && lens(FACE_SPHERE_REF_DIRECTION, 3 * n_s)+ && lens(FACE_SPHERE_RADIUS, n_s)+ && lens(FACE_TORUS_ORIGIN, 3 * n_to)+ && lens(FACE_TORUS_AXIS, 3 * n_to)+ && lens(FACE_TORUS_REF_DIRECTION, 3 * n_to)+ && lens(FACE_TORUS_MAJOR_RADIUS, n_to)+ && lens(FACE_TORUS_MINOR_RADIUS, n_to))+ {+ return None;+ }+ let positive = |id: i32, i: usize| f.r(id).get(i).is_some_and(|&r| r > 0.0);+ for i in 0..n_p {+ if !good_frame(f.r(FACE_PLANE_AXIS), f.r(FACE_PLANE_REF_DIRECTION), i) {+ return None;+ }+ }+ for i in 0..n_cy {+ if !positive(FACE_CYLINDER_RADIUS, i) || !good_frame(f.r(FACE_CYLINDER_AXIS), f.r(FACE_CYLINDER_REF_DIRECTION), i) {+ return None;+ }+ }+ for i in 0..n_co {+ let half = 0.5 * std::f64::consts::PI * (1.0 - 1e-9);+ if !f.r(FACE_CONE_RADIUS).get(i).is_some_and(|&r| r >= 0.0)+ || !f.r(FACE_CONE_SEMI_ANGLE).get(i).is_some_and(|a| a.abs() < half)+ || !good_frame(f.r(FACE_CONE_AXIS), f.r(FACE_CONE_REF_DIRECTION), i)+ {+ return None;+ }+ }+ for i in 0..n_s {+ if !positive(FACE_SPHERE_RADIUS, i) || !good_frame(f.r(FACE_SPHERE_AXIS), f.r(FACE_SPHERE_REF_DIRECTION), i) {+ return None;+ }+ }+ for i in 0..n_to {+ if !positive(FACE_TORUS_MAJOR_RADIUS, i)+ || !positive(FACE_TORUS_MINOR_RADIUS, i)+ || !good_frame(f.r(FACE_TORUS_AXIS), f.r(FACE_TORUS_REF_DIRECTION), i)+ {+ return None;+ }+ }+ Some(s)+}++// ---- import: FlatToBrepData --------------------------------------------------------------------++/// The running read positions in the packed geometry arrays (`Cursor`).+#[derive(Default)]+struct Cursor {+ nurbs: usize,+ cv: usize,+ knot: usize,+ vknot: usize,+ circle: usize,+ line: usize,+ ellipse: usize,+}++/// `smu_IsFlatKnotVectorClamped`: the first and last knots each repeat `degree + 1` times.+fn is_clamped(knots: &[f64], degree: usize) -> bool {+ let n = knots.len();+ if n < 2 || degree > (n - 2) / 2 {+ return false;+ }+ let (Some(&first), Some(&last)) = (knots.first(), knots.last()) else { return false };+ (1..=degree).all(|i| knots.get(i) == Some(&first) && knots.get(n - 1 - i) == Some(&last))+}++/// `smu_CompressFlatKnots`: the distinct knots and their multiplicities.+fn compress_knots(knots: &[f64]) -> (Vec<f64>, Vec<usize>) {+ let (mut unique, mut mults): (Vec<f64>, Vec<usize>) = (Vec::new(), Vec::new());+ for &k in knots {+ match (unique.last(), mults.last_mut()) {+ (Some(&u), Some(m)) if u == k => *m += 1,+ _ => {+ unique.push(k);+ mults.push(1);+ }+ }+ }+ (unique, mults)+}++/// `smu_CreateSmBSplineCurve_FromArrays`: a curve of `dim` 2 or 3; an unclamped knot vector goes+/// through `SmBSplineCurve::CreateCanonical`, which clamps it.+fn bspline_curve_from_arrays(points: &[Point3], weights: &[f64], knots: &[f64], degree: usize, dim: u64) -> Result<BSplineCurve> {+ if !is_clamped(knots, degree) {+ let (unique, mults) = compress_knots(knots);+ let data = CanonicalData {+ dim,+ degree,+ control_points: points,+ form: BSplineCurveForm::Unspecified,+ knot_multiplicities: &mults,+ knots: &unique,+ knot_type: KnotType::Unspecified,+ weights: Some(weights),+ trim: None,+ };+ return BSplineCurve::create_canonical(&data).map_err(sc("SmBSplineCurve::CreateCanonical"));+ }+ let mut pw = Vec::with_capacity(points.len());+ for (p, &w) in points.iter().zip(weights) {+ let z = if dim == 3 { if w == 1.0 { p.z } else { w * p.z } } else { NOZ };+ pw.push(if w == 1.0 { CPoint::new(p.x, p.y, z, 1.0) } else { CPoint::new(w * p.x, w * p.y, z, w) });+ }+ let nurb = NurbCurve::new(pw, degree, knots.to_vec()).map_err(sc("sm_AllocateNurbCurve"))?;+ let mut c = BSplineCurve::new(dim);+ c.set_from_gw_nurb(Some(&nurb)).map_err(sc("SmBSplineCurve::SetFromGwNurb"))?;+ Ok(c)+}++/// `smu_CreateSmBSplineSurface_FromArrays`: control points U-major; an unclamped knot vector goes+/// through `SmBSplineSurface::CreateCanonical`.+fn bspline_surface_from_arrays(+ points: &[Point3],+ weights: &[f64],+ u_knots: &[f64],+ v_knots: &[f64],+ u_degree: usize,+ v_degree: usize,+) -> Result<BSplineSurface> {+ if !is_clamped(u_knots, u_degree) || !is_clamped(v_knots, v_degree) {+ let (uu, um) = compress_knots(u_knots);+ let (vu, vm) = compress_knots(v_knots);+ let data = CanonicalSurfaceData {+ u_degree,+ v_degree,+ control_points: points,+ form: BSplineSurfaceForm::Unspecified,+ u_multiplicities: &um,+ v_multiplicities: &vm,+ u_knots: &uu,+ v_knots: &vu,+ knot_type: KnotType::Unspecified,+ weights: Some(weights),+ uv_domain: None,+ };+ return BSplineSurface::create_canonical(&data).map_err(sc("SmBSplineSurface::CreateCanonical"));+ }+ let nu = u_knots.len().checked_sub(u_degree + 1).ok_or_else(|| bad("u knots"))?;+ let nv = v_knots.len().checked_sub(v_degree + 1).ok_or_else(|| bad("v knots"))?;+ let mut net = Vec::with_capacity(nu);+ for i in 0..nu {+ let mut row = Vec::with_capacity(nv);+ for j in 0..nv {+ let at = i * nv + j;+ let (p, w) = (get(points, at)?, get(weights, at)?);+ row.push(CPoint::new(w * p.x, w * p.y, w * p.z, w));+ }+ net.push(row);+ }+ let nurb = NurbSurface::new(net, u_degree, v_degree, u_knots.to_vec(), v_knots.to_vec()).map_err(sc("sm_AllocateNurbSurface"))?;+ Ok(BSplineSurface::from_nurb(nurb, false))+}++/// The packed control points `[c, c + n)` of `dim` coordinates (z 0 for 2D) and their weights,+/// all 1 without a weight array.+fn packed_points(cvs: &[f64], weights: &[f64], c: usize, n: usize, dim: usize, reversed: bool) -> Result<(Vec<Point3>, Vec<f64>)> {+ let weighted = weights.len() * dim == cvs.len();+ let (mut pts, mut ws) = (Vec::with_capacity(n), Vec::with_capacity(n));+ for j in 0..n {+ let src = c + if reversed { n - 1 - j } else { j };+ let p = if dim == 3 { get3(cvs, src)? } else { Vec3::new(get(cvs, 2 * src)?, get(cvs, 2 * src + 1)?, 0.0) };+ pts.push(p);+ ws.push(if weighted { get(weights, src)? } else { 1.0 });+ }+ Ok((pts, ws))+}++/// `smu_CreateSmBSplineCurve3d`: the next NURBS curve of an edge family.+fn bspline_curve_3d(e: &EdgeIn<'_>, c: &mut Cursor) -> Result<BSplineCurve> {+ let degree = idx(get(e.order, c.nurbs)? - 1)?;+ let n = idx(get(e.count, c.nurbs)?)?;+ let n_knots = n + degree + 1;+ let (points, weights) = packed_points(e.cvs, e.weights, c.cv, n, 3, false)?;+ let knots = e.knots.get(c.knot..c.knot + n_knots).ok_or_else(|| bad("edge knots"))?;+ let curve = bspline_curve_from_arrays(&points, &weights, knots, degree, 3);+ c.nurbs += 1;+ c.cv += n;+ c.knot += n_knots;+ curve+}++/// `smu_CreateSmBSplineCurve2d_ForEdgeuseIndex`: edgeuse `k`'s UV trim, reversed onto its edge's+/// direction and its knots mapped affinely onto the edge's range (in SMLib units); `None` when it+/// has none, or its face no NURBS block (an analytic face's trims are rebuilt from the edges).+fn bspline_curve_2d(f: &In<'_>, c: &mut Cursor, k: usize, face_has_nurbs: bool, same: bool) -> Result<Option<BSplineCurve>> {+ let (order, n) = (get(f.i(EDGEUSE_NURBS_ORDER), k)?, get(f.i(EDGEUSE_NURBS_VERTEX_COUNT), k)?);+ if order == 0 || n == 0 {+ return Ok(None);+ }+ let degree = idx(order - 1)?;+ let n = idx(n)?;+ let n_knots = n + degree + 1;+ let (cv, knot) = (c.cv, c.knot);+ c.cv += n;+ c.knot += n_knots;+ if !face_has_nurbs {+ return Ok(None);+ }+ let (points, weights) = packed_points(f.r(EDGEUSE_NURBS_CVS), f.r(EDGEUSE_NURBS_WEIGHTS), cv, n, 2, !same)?;+ // SMLib requires every UV trim to run over its edge's interval: map the knots affinely onto+ // the edge's range (degrees for an analytic circle or ellipse)+ let e = idx(get(f.i(EDGEUSE_EDGE), k)?)?;+ let (mut lo, mut hi) = (get(f.r(EDGE_RANGE), 2 * e)?, get(f.r(EDGE_RANGE), 2 * e + 1)?);+ let ty = get(f.i(EDGE_CURVE_TYPE), e)?;+ if (ty == CURVE_CIRCLE_I || ty == CURVE_ELLIPSE_I) && !has_form(f.i(EDGE_NURBS_FORM), e) {+ lo = radians_to_smlib_degrees(lo);+ hi = radians_to_smlib_degrees(hi);+ }+ let src = f.r(EDGEUSE_NURBS_KNOTS).get(knot..knot + n_knots).ok_or_else(|| bad("trim knots"))?;+ let (s_lo, s_hi) = (get(src, degree)?, get(src, n)?);+ let scale = (hi - lo) / (s_hi - s_lo);+ let mut knots = Vec::with_capacity(n_knots);+ for j in 0..n_knots {+ let s = if same { get(src, j)? } else { s_lo + s_hi - get(src, n_knots - 1 - j)? };+ knots.push(lo + (s - s_lo) * scale);+ }+ bspline_curve_from_arrays(&points, &weights, &knots, degree, 2).map(Some)+}++/// `smu_CreateSmBSplineSurface3d`: the next NURBS face's surface.+fn bspline_surface_3d(f: &In<'_>, c: &mut Cursor) -> Result<BSplineSurface> {+ let ud = idx(get(f.i(FACE_NURBS_U_ORDER), c.nurbs)? - 1)?;+ let vd = idx(get(f.i(FACE_NURBS_V_ORDER), c.nurbs)? - 1)?;+ let nu = idx(get(f.i(FACE_NURBS_U_VERTEX_COUNT), c.nurbs)?)?;+ let nv = idx(get(f.i(FACE_NURBS_V_VERTEX_COUNT), c.nurbs)?)?;+ let (nuk, nvk, n) = (nu + ud + 1, nv + vd + 1, nu * nv);+ let (points, weights) = packed_points(f.r(FACE_NURBS_CVS), f.r(FACE_NURBS_WEIGHTS), c.cv, n, 3, false)?;+ let uk = f.r(FACE_NURBS_U_KNOTS).get(c.knot..c.knot + nuk).ok_or_else(|| bad("u knots"))?;+ let vk = f.r(FACE_NURBS_V_KNOTS).get(c.vknot..c.vknot + nvk).ok_or_else(|| bad("v knots"))?;+ let s = bspline_surface_from_arrays(&points, &weights, uk, vk, ud, vd);+ c.nurbs += 1;+ c.cv += n;+ c.knot += nuk;+ c.vknot += nvk;+ s+}++/// `SameNurbs`: equal sizes and orders, knots and weights within rounding, control points within+/// `tol`.+fn same_nurbs(a: &NurbSurface, b: &NurbSurface, tol: f64) -> bool {+ let (mut fa, mut fb) = (Out::new(), Out::new());+ if add_bspline_surface(&mut fa, a).is_err() || add_bspline_surface(&mut fb, b).is_err() {+ return false;+ }+ for id in [FACE_NURBS_U_VERTEX_COUNT, FACE_NURBS_V_VERTEX_COUNT, FACE_NURBS_U_ORDER, FACE_NURBS_V_ORDER] {+ if fa.i(id) != fb.i(id) {+ return false;+ }+ }+ let close = |x: &[f64], y: &[f64], t: f64| x.len() == y.len() && x.iter().zip(y).all(|(a, b)| (a - b).abs() <= t * a.abs().max(1.0));+ close(fa.r(FACE_NURBS_U_KNOTS), fb.r(FACE_NURBS_U_KNOTS), 1e-12)+ && close(fa.r(FACE_NURBS_V_KNOTS), fb.r(FACE_NURBS_V_KNOTS), 1e-12)+ && close(fa.r(FACE_NURBS_WEIGHTS), fb.r(FACE_NURBS_WEIGHTS), 1e-12)+ && close(fa.r(FACE_NURBS_CVS), fb.r(FACE_NURBS_CVS), tol)+}++/// `AnalyticOfNurbs`: the analytic surface of kind `ty` SMLib's own test finds in `nurbs`, kept+/// only when its NURBS is `nurbs` (the face's trims are in its parameters).+fn analytic_of_nurbs(k: &Kernel, nurbs: &BSplineSurface, ty: i64, tol: f64) -> Result<Option<Surface>> {+ let found: Option<Surface> = if ty == SURFACE_CONE_I {+ answer(Cone::is_nurb_surface_cone(k, nurbs, 1.0)).map_err(sc("SmCone::IsNurbSurfaceCone"))?.flatten().map(Surface::from)+ } else if ty == SURFACE_SPHERE_I {+ answer(Sphere::is_nurb_surface_sphere(k, nurbs, 1.0)).map_err(sc("SmSphere::IsNurbSurfaceSphere"))?.flatten().map(Surface::from)+ } else if ty == SURFACE_CYLINDER_I {+ answer(Cone::is_nurb_surface_cylinder(k, nurbs, 1.0)).map_err(sc("SmCylinder::IsNurbSurfaceCylinder"))?.flatten().map(Surface::from)+ } else if ty == SURFACE_TORUS_I {+ answer(Torus::is_nurb_surface_torus(k, nurbs, 1.0)).map_err(sc("SmTorus::IsNurbSurfaceTorus"))?.flatten().map(Surface::from)+ } else {+ None+ };+ let Some(found) = found else { return Ok(None) };+ let (Some(want), Some(part)) = (nurbs.gw_nurb(), bspline_surface_part(k, &found)?) else { return Ok(None) };+ Ok(part.gw_nurb().is_some_and(|got| same_nurbs(want, got, tol)).then_some(found))+}++/// `Placement`: X the reference direction, Y the axis cross it (`SetCanonical`).+fn placement(origin: Point3, z: Vec3, x: Vec3) -> Result<Axis2Placement> {+ let mut p = Axis2Placement::default();+ p.set_canonical(origin, x, z.cross(x)).map_err(|_| bad("a frame that spans no plane"))?;+ Ok(p)+}++/// `SameNurbsCurve`: equal counts and orders, knots and weights within rounding, control points+/// within rounding of the curve's size (`smu_AddSmBSplineCurve3d` of each).+fn same_nurbs_curve(a: &NurbCurve, b: &NurbCurve) -> bool {+ let arrays = |n: &NurbCurve| {+ let (mut count, mut order, mut cvs, mut knots, mut weights) = (Vec::new(), Vec::new(), Vec::new(), Vec::new(), Vec::new());+ let o = NurbsOut { count: &mut count, order: &mut order, cvs: &mut cvs, knots: &mut knots, weights: &mut weights };+ add_bspline_curve_3d(n, o).ok().map(|()| (count, order, cvs, knots, weights))+ };+ let (Some((ac, ao, ap, ak, aw)), Some((bc, bo, bp, bk, bw))) = (arrays(a), arrays(b)) else { return false };+ if ac != bc || ao != bo || ap.len() != bp.len() || ak.len() != bk.len() || aw.len() != bw.len() {+ return false;+ }+ let size = ap.iter().fold(1.0_f64, |m, x| m.max(x.abs()));+ let near = |x: &[f64], y: &[f64]| x.iter().zip(y).all(|(a, b)| (a - b).abs() <= 1e-12 * a.abs().max(1.0));+ ap.iter().zip(&bp).all(|(a, b)| (a - b).abs() <= 1e-12 * size) && near(&ak, &bk) && near(&aw, &bw)+}++/// `MakeEdgeCurve` (capi/src/smlib_flat.cpp): one edge's 3D curve, as its kind says;+/// `d_min`/`d_max` its range in SMLib units. A circle or ellipse with its NURBS form (`form`) is that NURBS as the conic of its+/// canonical entry (frame and radii; the domain from `ConicDomainOfNurbs`), keeping that NURBS.+/// A circle's NURBS must pass SMLib's own test (`SmCircle::IsNurbCurveCircle`), whose circle is+/// not the one kept (its frame has its x axis towards the NURBS's start), and the kept circle+/// must hold the same NURBS (`SameNurbsCurve`); either failing is `SM_ERR_INVALID_INPUT`.+fn make_edge_curve(k: &Kernel, ty: i64, d_min: f64, d_max: f64, e: &EdgeIn<'_>, c: &mut Cursor, form: bool) -> Result<Curve> {+ if form {+ let circle = ty == CURVE_CIRCLE_I;+ let i = if circle {+ c.circle += 1;+ c.circle - 1+ } else {+ c.ellipse += 1;+ c.ellipse - 1+ };+ let nurbs = bspline_curve_3d(e, c)?;+ let (o, mut z, mut x, rx, ry) = if circle {+ let r = get(e.circle_radius, i)?;+ (get3(e.circle_center, i)?, get3(e.circle_axis, i)?, get3(e.circle_ref, i)?, r, r)+ } else {+ (get3(e.ellipse_center, i)?, get3(e.ellipse_axis, i)?, get3(e.ellipse_ref, i)?, get(e.ellipse_x, i)?, get(e.ellipse_y, i)?)+ };+ if circle {+ let test = Curve::from(nurbs.clone_exact());+ let is_circle = answer(Ellipse::is_nurb_curve_circle(k, &test, None)).map_err(sc("SmCircle::IsNurbCurveCircle"))?.flatten();+ if is_circle.is_none() {+ return Err(bad("a circle NURBS SMLib's circle test rejects"));+ }+ }+ let domain = conic_domain_of_nurbs(&nurbs, o, &mut z, &mut x, rx, ry).ok_or_else(|| bad("a conic NURBS off its conic"))?;+ let opts = EllipseOptions { dim: 3, nurb: Some(&nurbs), inside_out: false };+ if circle {+ let cir = Ellipse::new_circle(k, o, x, z.cross(x), domain, rx, &opts).map_err(sc("SmCircle::SmCircle"))?;+ let kept = nurb_of(cir.base())?;+ if !nurbs.gw_nurb().is_some_and(|want| same_nurbs_curve(want, kept)) {+ return Err(bad("a circle that does not keep its NURBS"));+ }+ return Ok(Curve::from(cir));+ }+ let el = Ellipse::new(k, o, x, z.cross(x), domain, rx, ry, &opts).map_err(sc("SmEllipse::SmEllipse"))?;+ return Ok(Curve::from(el));+ }+ if ty == CURVE_NURBS_I {+ return bspline_curve_3d(e, c).map(Curve::from);+ }+ if ty == CURVE_CIRCLE_I {+ let i = c.circle;+ c.circle += 1;+ let r = get(e.circle_radius, i)?;+ return build_analytic_edge_curve(k, ty, d_min, d_max, get3(e.circle_center, i)?, get3(e.circle_axis, i)?, get3(e.circle_ref, i)?, r, r);+ }+ if ty == CURVE_LINE_I {+ let i = c.line;+ c.line += 1;+ let zero = Vec3::new(0.0, 0.0, 0.0);+ return build_analytic_edge_curve(k, ty, d_min, d_max, get3(e.line_origin, i)?, get3(e.line_direction, i)?, zero, 0.0, 0.0);+ }+ let i = c.ellipse;+ c.ellipse += 1;+ build_analytic_edge_curve(+ k,+ ty,+ d_min,+ d_max,+ get3(e.ellipse_center, i)?,+ get3(e.ellipse_axis, i)?,+ get3(e.ellipse_ref, i)?,+ get(e.ellipse_x, i)?,+ get(e.ellipse_y, i)?,+ )+}++/// `ConicDomainOfNurbs`: the domain in degrees of the conic (centre `o`, axis `z`, reference `x`,+/// radii `rx`, `ry`) the NURBS traces, `z` and `x` made an orthonormal frame; `None` when a point+/// is off that conic or the NURBS turns clockwise about `z`.+fn conic_domain_of_nurbs(nurbs: &BSplineCurve, o: Point3, z: &mut Vec3, x: &mut Vec3, rx: f64, ry: f64) -> Option<Extent1d> {+ *z = z.unitize().ok()?;+ *x = (*x - *z * x.dot(*z)).unitize().ok()?;+ if !(rx > 0.0 && ry > 0.0) {+ return None;+ }+ let y = z.cross(*x);+ let ivl = nurbs.natural_interval();+ let angle = |t: f64| -> Option<f64> {+ let p = nurbs.evaluate_point(t).ok()?;+ let d = p - o;+ let (u, v) = (d.dot(*x) / rx, d.dot(y) / ry);+ let on = ((u.hypot(v)) - 1.0).abs() <= 1e-9 && d.dot(*z).abs() <= 1e-9 * (1.0 + rx + ry);+ on.then(|| v.atan2(u) * 180.0 / std::f64::consts::PI)+ };+ let n = 16;+ let (mut a0, mut prev) = (0.0, 0.0);+ for step in 0..=n {+ let a = angle(ivl.min() + (ivl.max() - ivl.min()) * f64::from(step) / f64::from(n))?;+ if step == 0 {+ a0 = a;+ } else if !(ieee_remainder(a - prev, 360.0) > 0.0) {+ return None;+ }+ prev = a;+ }+ let mut sweep = (prev - a0 + 720.0) % 360.0;+ if sweep <= 1e-9 {+ sweep = 360.0;+ }+ if a0 + sweep > 360.0 { Some(Extent1d::from_raw(a0 - 360.0, a0 - 360.0 + sweep)) } else { Some(Extent1d::from_raw(a0, a0 + sweep)) }+}++/// `std::remainder`: `x - n * y` with `n` the integer nearest `x / y`, ties to even.+fn ieee_remainder(x: f64, y: f64) -> f64 {+ let q = x / y;+ let mut n = q.round();+ if (q - q.trunc()).abs() == 0.5 && n % 2.0 != 0.0 {+ n -= q.signum();+ }+ x - n * y+}++/// `FlatToBrepData`: the validated arrays as `SmBrepData`. Edges are `[face edges, wire edges]`,+/// vertices `[point-shell vertices, vertices]`, edgeuses `[wire edgeuses, face edgeuses]`.+fn flat_to_brep_data(k: &Kernel, f: &In<'_>, s: &Shape) -> Result<BrepData> {+ let xsect = get(f.r(TOLERANCE), 0)?;+ let zone = xsect / 2.0;+ let mut d = BrepData::new(UNSURE, DataSourceType::default());+ d.data_source_type = DataSourceType::Usd;+ d.zone_tol_3d = zone;+ d.approx_tol_3d = xsect / 4.0;+ d.start_region = 0;+ d.num_regions = s.regions as u64;+ d.color = Vec3::new(0.0, 0.0, 0.0);+ d.is_geom_borrowed = false;+ let mut next_key = 1u64;+ let mut key = || {+ next_key += 1;+ ObjectKey(next_key - 1)+ };+ let (n_edges, n_wire, n_point) = (s.edges as u64, s.wire_edges as u64, s.point_shells as u64);+ let undefined = |t: &mut solidcore::topology::brep_data::TopologyData| {+ t.flags = 0;+ t.user_index1 = 0;+ t.user_index2 = 0;+ };++ // Regions+ let mut start_shell = 0u64;+ for i in 0..s.regions {+ let mut r = RegionData::default();+ r.start_shell = start_shell;+ r.num_shells = get(f.i(REGION_SHELL_COUNT), i)? as u64;+ r.is_void = i32::from(get(f.i(REGION_TYPE), i)? == 1);+ undefined(&mut r.topology);+ start_shell += r.num_shells;+ d.regions.push(r);+ }++ // Shells, the wire edges' edgeuses (first in the edgeuse list) and point-shell vertices+ let mut faceuse_start = 0u64;+ let mut wire = 0u64;+ let mut point = 0usize;+ for i in 0..s.shells {+ let mut sd = ShellData::default();+ let (n_fu, n_we) = (get(f.i(SHELL_FACEUSE_COUNT), i)? as u64, get(f.i(SHELL_WIRE_EDGE_COUNT), i)? as u64);+ sd.shell_type = if n_fu > 0 {+ 0+ } else if n_we > 0 {+ 1+ } else {+ 2+ };+ sd.num_faceuses = 0;+ undefined(&mut sd.topology);+ if n_fu > 0 {+ sd.faceuse_start = faceuse_start;+ sd.num_faceuses = n_fu;+ faceuse_start += n_fu;+ }+ if n_we > 0 {+ sd.edge = wire + n_edges;+ for _ in 0..n_we {+ let mut eu = EuData::default();+ eu.eu_type = 2;+ eu.edge = n_edges + wire;+ eu.shell = i as u64;+ eu.orientation = 1;+ undefined(&mut eu.topology);+ eu.mate_flags = 0;+ eu.mate_user_index1 = 0;+ eu.mate_user_index2 = 0;+ eu.uv_curve = NO_OBJECT;+ d.edgeuses.push(eu);+ wire += 1;+ }+ }+ if sd.shell_type == 2 {+ sd.vertex = point as u64;+ let mut v = VertexData::default();+ v.zone_tol_3d = zone;+ undefined(&mut v.topology);+ v.point = get3(f.r(SHELL_POINT_POSITION), point)?;+ d.vertices.push(v);+ point += 1;+ }+ d.shells.push(sd);+ }++ // Faceuses+ for i in 0..s.faceuses {+ let mut fu = FaceuseData::default();+ fu.face = get(f.i(FACEUSE_FACE), i)? as u64;+ fu.orientation = i32::from(get(f.i(FACEUSE_ORIENTATION), i)? == 1);+ undefined(&mut fu.topology);+ d.faceuses.push(fu);+ }++ // Faces and their surfaces+ let mut start_loop = 0u64;+ let mut nurbs_cursor = Cursor::default();+ let (mut i_sphere, mut i_plane, mut i_cyl, mut i_cone, mut i_torus) = (0usize, 0usize, 0usize, 0usize, 0usize);+ for i in 0..s.faces {+ let ty = get(f.i(FACE_SURFACE_TYPE), i)?;+ let form = ty != SURFACE_NURBS_I && face_has_nurbs(f, i);+ // "rectangular" -> TRUE; "general" -> UNSURE (not determined)+ let rectangular = if get(f.i(FACE_TRIM_TYPE), i)? == 1 { 1 } else { UNSURE };+ let r = f.r(FACE_RANGE);+ let (mut u0, mut v0, mut u1, mut v1) = (get(r, 4 * i)?, get(r, 4 * i + 1)?, get(r, 4 * i + 2)?, get(r, 4 * i + 3)?);+ // analytic angles: radians to SMLib's degrees (a NURBS form's range is its own)+ if !form {+ if ty == SURFACE_SPHERE_I || ty == SURFACE_TORUS_I {+ (u0, v0, u1, v1) =+ (radians_to_smlib_degrees(u0), radians_to_smlib_degrees(v0), radians_to_smlib_degrees(u1), radians_to_smlib_degrees(v1));+ } else if ty == SURFACE_CYLINDER_I || ty == SURFACE_CONE_I {+ (u0, u1) = (radians_to_smlib_degrees(u0), radians_to_smlib_degrees(u1));+ }+ }+ let mut domain = extent2d(u0, v0, u1, v1)?;+ let mut fd = FaceData::default();+ fd.zone_tol_3d = zone;+ fd.surface = d.surfaces.len() as u64;+ fd.start_loop = start_loop;+ fd.num_loops = get(f.i(FACE_LOOP_COUNT), i)? as u64;+ fd.uv_domain = domain;+ fd.rectangular_trim = rectangular;+ undefined(&mut fd.topology);++ let mut surface: Surface = if form {+ // an analytic face with its NURBS form: that NURBS as the class the arrays name+ i_sphere += usize::from(ty == SURFACE_SPHERE_I);+ i_cyl += usize::from(ty == SURFACE_CYLINDER_I);+ i_cone += usize::from(ty == SURFACE_CONE_I);+ i_torus += usize::from(ty == SURFACE_TORUS_I);+ let nurbs = bspline_surface_3d(f, &mut nurbs_cursor)?;+ analytic_of_nurbs(k, &nurbs, ty, xsect)?.ok_or_else(|| bad("a NURBS form that is not its analytic surface"))?+ } else if ty == SURFACE_SPHERE_I {+ let j = i_sphere;+ i_sphere += 1;+ let p = placement(get3(f.r(FACE_SPHERE_CENTER), j)?, get3(f.r(FACE_SPHERE_AXIS), j)?, get3(f.r(FACE_SPHERE_REF_DIRECTION), j)?)?;+ Surface::from(Sphere::create_canonical(k, &p, get(f.r(FACE_SPHERE_RADIUS), j)?).map_err(sc("SmSphere::CreateCanonical"))?)+ } else if ty == SURFACE_PLANE_I {+ let j = i_plane;+ i_plane += 1;+ let p = placement(get3(f.r(FACE_PLANE_ORIGIN), j)?, get3(f.r(FACE_PLANE_AXIS), j)?, get3(f.r(FACE_PLANE_REF_DIRECTION), j)?)?;+ // its domain is restricted below without changing its parameterisation+ Surface::from(Plane::create_canonical(&p).map_err(sc("SmPlane::CreateCanonical"))?)+ } else if ty == SURFACE_CYLINDER_I {+ let j = i_cyl;+ i_cyl += 1;+ let p = placement(get3(f.r(FACE_CYLINDER_ORIGIN), j)?, get3(f.r(FACE_CYLINDER_AXIS), j)?, get3(f.r(FACE_CYLINDER_REF_DIRECTION), j)?)?;+ Surface::from(Cone::create_canonical_cylinder(k, &p, get(f.r(FACE_CYLINDER_RADIUS), j)?).map_err(sc("SmCylinder::CreateCanonical"))?)+ } else if ty == SURFACE_CONE_I {+ let j = i_cone;+ i_cone += 1;+ let mut origin = get3(f.r(FACE_CONE_ORIGIN), j)?;+ let mut z = get3(f.r(FACE_CONE_AXIS), j)?;+ let x = get3(f.r(FACE_CONE_REF_DIRECTION), j)?;+ let radius = get(f.r(FACE_CONE_RADIUS), j)?;+ let mut semi = rad2deg(get(f.r(FACE_CONE_SEMI_ANGLE), j)?);+ // a negative semi-angle is the same cone with its axis and both parameters reversed+ if semi < 0.0 {+ semi = -semi;+ z = Vec3::new(-z.x, -z.y, -z.z);+ domain = extent2d(-domain.u_max(), -domain.v_max(), -domain.u_min(), -domain.v_min())?;+ }+ let mut cone = None;+ if domain.is_bounded() {+ // the finite segment, built at its bottom and its axial parameter then [0, height]+ let (vmin, vmax) = (domain.v_min(), domain.v_max());+ let height = vmax - vmin;+ let tan = deg2rad(semi).tan();+ let (bottom, top) = (radius + vmin * tan, radius + vmax * tan);+ if height > EFF_ZERO && bottom >= -EFF_ZERO && top >= -EFF_ZERO {+ origin += z * vmin;+ let p = placement(origin, z, x)?;+ cone = Some(+ Cone::create_canonical(k, &p, bottom.max(0.0), top.max(0.0), height, false, false).map_err(sc("SmCone::CreateCanonical")),+ );+ domain = extent2d(domain.u_min(), 0.0, domain.u_max(), height)?;+ }+ } else {+ let p = placement(origin, z, x)?;+ cone = Some(Cone::create_canonical_with_semi_angle(k, &p, radius, semi, None, false, false).map_err(sc("SmCone::CreateCanonical")));+ }+ Surface::from(cone.ok_or_else(|| bad("a cone segment through its apex"))??)+ } else if ty == SURFACE_TORUS_I {+ let j = i_torus;+ i_torus += 1;+ let p = placement(get3(f.r(FACE_TORUS_ORIGIN), j)?, get3(f.r(FACE_TORUS_AXIS), j)?, get3(f.r(FACE_TORUS_REF_DIRECTION), j)?)?;+ let (major, minor) = (get(f.r(FACE_TORUS_MAJOR_RADIUS), j)?, get(f.r(FACE_TORUS_MINOR_RADIUS), j)?);+ Surface::from(Torus::create_canonical(k, &p, major, minor, TorusOptions::default(), None).map_err(sc("SmTorus::CreateCanonical"))?)+ } else {+ Surface::from(bspline_surface_3d(f, &mut nurbs_cursor)?)+ };++ // An analytic surface over its STEP range, and the face's domain its NURBS image (the+ // natural domain the topology build intersects with).+ if ty != SURFACE_NURBS_I && !form && domain.is_bounded() {+ surface.adjust_step_uv_domain(k, &domain).map_err(sc("AdjustSTEPUVDomain"))?;+ let nurbs_domain = surface.convert_domain_from_step_to_nurbs(k, &domain).map_err(sc("ConvertDomainFromSTEPToNURBS"))?;+ fd.uv_domain = extent2d(nurbs_domain.u_min(), nurbs_domain.v_min(), nurbs_domain.u_max(), nurbs_domain.v_max())?;+ }+ d.surfaces.push(Keyed { key: key(), object: surface });+ start_loop += fd.num_loops;+ d.faces.push(fd);+ }++ // Loops; each edgeuse's loop and face follow from the loop counts+ let mut eu_loop = vec![0u64; s.edgeuses];+ let mut eu_face = vec![0usize; s.edgeuses];+ // (face, vertex) of each vertex loop+ let mut loop_vertices = Vec::new();+ {+ let mut next_eu = n_wire;+ let (mut eu, mut face) = (0usize, 0usize);+ let mut face_loop_end = if s.faces > 0 { get(f.i(FACE_LOOP_COUNT), 0)? as usize } else { 0 };+ for l in 0..s.loops {+ while l >= face_loop_end && face + 1 < s.faces {+ face += 1;+ face_loop_end += get(f.i(FACE_LOOP_COUNT), face)? as usize;+ }+ let n_eu = get(f.i(LOOP_EDGEUSE_COUNT), l)? as u64;+ let mut ld = LoopData::default();+ ld.loop_type = if n_eu > 0 { 0 } else { 1 };+ ld.num_eu = n_eu;+ undefined(&mut ld.topology);+ if n_eu > 0 {+ ld.start_eu = next_eu;+ next_eu += n_eu;+ for _ in 0..n_eu {+ *eu_loop.get_mut(eu).ok_or_else(|| bad("edgeuse count"))? = l as u64;+ *eu_face.get_mut(eu).ok_or_else(|| bad("edgeuse count"))? = face;+ eu += 1;+ }+ } else {+ // no SmEUData for a loop vertex+ ld.vertex = n_point + get(f.i(LOOP_VERTEX), l)? as u64;+ loop_vertices.push((face, ld.vertex));+ }+ d.loops.push(ld);+ }+ }++ // Edgeuses (face edges; the wire edges' came with their shells)+ let mut prim_eu = vec![NO_OBJECT as i64; s.edges];+ let mut uv_cursor = Cursor::default();+ let (eu_next, eu_entry) = (f.i(EDGEUSE_NEXT_RADIAL), f.i(EDGEUSE_RADIAL_ENTRY));+ for kk in 0..s.edgeuses {+ let here = (n_wire + kk as u64) as i64;+ let next = idx(get(eu_next, kk)?)?;+ let next_index = (n_wire as i64) + next as i64;+ let this_top = get(eu_entry, kk)? == 1;+ let next_top = get(eu_entry, next)? == 1;+ let next_flag = if next_top { next_index } else { -next_index - 1 };+ let same = get(f.i(EDGEUSE_ORIENTATION), kk)? == 1;+ let mut eu = EuData::default();+ eu.eu_type = 0;+ eu.edge = get(f.i(EDGEUSE_EDGE), kk)? as u64;+ eu.loop_ = get(&eu_loop, kk)?;+ eu.orientation = i32::from(same);+ eu.downward_lu = false;+ undefined(&mut eu.topology);+ // topEntry: top -> bottom -> next; bottomEntry: bottom -> top -> next+ if this_top {+ eu.next_eu = -here - 1;+ eu.mate_next_eu = next_flag;+ } else {+ eu.next_eu = next_flag;+ eu.mate_next_eu = here;+ }+ eu.uv_curve = NO_OBJECT;+ if s.uv_curves+ && let Some(trim) = bspline_curve_2d(f, &mut uv_cursor, kk, face_has_nurbs(f, get(&eu_face, kk)?), same)?+ {+ eu.uv_curve = d.uv_curves.len() as u64;+ d.uv_curves.push(Keyed { key: key(), object: Curve::from(trim) });+ }+ // the primary edgeuse is the first on the radial list (its mate the second)+ let slot = prim_eu.get_mut(index_u64(eu.edge)?).ok_or_else(|| bad("edgeuse edge"))?;+ if *slot == NO_OBJECT as i64 {+ *slot = if this_top { here } else { -here - 1 };+ }+ d.edgeuses.push(eu);+ }++ // Edges, then wire edges+ for (family, n, offset) in [(&EDGES, s.edges, 0u64), (&WIRE_EDGES, s.wire_edges, n_edges)] {+ let e = EdgeIn::new(f, family);+ let tolerances = if offset == 0 { f.r(EDGE_TOLERANCE) } else { &[] };+ let mut c = Cursor::default();+ for i in 0..n {+ let mut ed = EdgeData::default();+ ed.zone_tol_3d = if tolerances.is_empty() { zone } else { get(tolerances, i)? / 2.0 };+ let ty = get(e.ty, i)?;+ let form = has_form(e.form, i);+ let (mut lo, mut hi) = (get(e.range, 2 * i)?, get(e.range, 2 * i + 1)?);+ // circle and ellipse ranges are radians; SMLib's circles and ellipses take degrees+ if !form && (ty == CURVE_CIRCLE_I || ty == CURVE_ELLIPSE_I) {+ (lo, hi) = (radians_to_smlib_degrees(lo), radians_to_smlib_degrees(hi));+ }+ if !(lo <= hi) {+ return Err(bad("edge range"));+ }+ ed.interval = Extent1d::from_raw(lo, hi);+ ed.curve = d.curves_3d.len() as u64;+ ed.start_vertex = n_point + get(e.vertices, 2 * i)? as u64;+ ed.end_vertex = n_point + get(e.vertices, 2 * i + 1)? as u64;+ // a wire edge's edgeuse index is its index among the wire edges+ ed.prim_eu = if offset == 0 { get(&prim_eu, i)? } else { i as i64 };+ undefined(&mut ed.topology);+ let curve = make_edge_curve(k, ty, lo, hi, &e, &mut c, form)?;+ d.curves_3d.push(Keyed { key: key(), object: curve });+ d.edges.push(ed);+ }+ }++ // Vertices+ for v in 0..s.vertices {+ let mut vd = VertexData::default();+ vd.zone_tol_3d = match f.r(VERTEX_TOLERANCE) {+ [] => zone,+ t => get(t, v)? / 2.0,+ };+ undefined(&mut vd.topology);+ vd.point = get3(f.r(VERTEX_POSITION), v)?;+ d.vertices.push(vd);+ }+ own_tolerances(&mut d, f, &eu_face, &loop_vertices, n_point)?;+ Ok(d)+}++/// The B-rep's and each face's tolerance from the edges' and vertices' own, when the arrays carry+/// them. TOLERANCE is the largest tolerance in arrays SMLib writes, and MakeTopologyFromData+/// raises every entity to the B-rep's: taken as the B-rep's, it would become every entity's, and+/// each crossing between the kernels spread the largest over the whole body. Each written edge or+/// vertex tolerance is at least the B-rep's and its faces' (`ZoneTolWithFaces`), so the B-rep's is+/// at most the least of them and a face's at most the least of its edges' and loop vertices'.+fn own_tolerances(d: &mut BrepData, f: &In<'_>, eu_face: &[usize], loop_vertices: &[(usize, u64)], n_point: u64) -> Result<()> {+ if f.r(EDGE_TOLERANCE).is_empty() || f.r(VERTEX_TOLERANCE).is_empty() {+ return Ok(());+ }+ let zone = d.zone_tol_3d;+ let mut faces = vec![f64::INFINITY; d.faces.len()];+ let mut lower = |face: usize, t: f64| -> Result<()> {+ let slot = faces.get_mut(face).ok_or_else(|| bad("edgeuse face"))?;+ *slot = slot.min(t);+ Ok(())+ };+ for (kk, &face) in eu_face.iter().enumerate() {+ let edge = index_u64(get(f.i(EDGEUSE_EDGE), kk)? as u64)?;+ lower(face, d.edges.get(edge).ok_or_else(|| bad("edgeuse edge"))?.zone_tol_3d)?;+ }+ for &(face, vertex) in loop_vertices {+ lower(face, d.vertices.get(index_u64(vertex)?).ok_or_else(|| bad("loop vertex"))?.zone_tol_3d)?;+ }+ let face_edges = d.edges.len().min(f.r(EDGE_TOLERANCE).len());+ let own_vertices = d.vertices.iter().skip(index_u64(n_point)?).map(|v| v.zone_tol_3d);+ let least = d.edges.iter().take(face_edges).map(|e| e.zone_tol_3d).chain(own_vertices).fold(zone, f64::min);+ if !(least.is_finite() && least > 0.0) {+ return Ok(());+ }+ d.zone_tol_3d = least;+ for (fd, t) in d.faces.iter_mut().zip(faces) {+ fd.zone_tol_3d = if t.is_finite() { t.min(zone) } else { zone };+ }+ Ok(())+}++/// An `SmExtent2d` with its ends in order (`Set`, `SetMinMax`).+fn extent2d(u0: f64, v0: f64, u1: f64, v1: f64) -> Result<Extent2d> {+ if !(u0 <= u1 && v0 <= v1) {+ return Err(bad("a domain with its ends reversed"));+ }+ Ok(Extent2d::from_bounds(u0, v0, u1, v1))+}++/// Whether `Validate` refuses these arrays.+#[cfg(all(test, feature = "native"))]+pub(super) fn validate_refuses(a: &Arrays) -> bool {+ validate(&In(a)).is_none()+}++/// A body from the flat arrays the C API imports (`BrepFromFlat`): `Validate`,+/// `FlatToBrepData`, then `MakeTopologyFromData` with the B-rep's tolerance as it is ([`own_tolerances`]) and no UV+/// trims or analytic conversion made; it heals unless `SOURCE` says SMLib wrote the arrays.+pub(crate) fn from_arrays(a: &Arrays) -> Result<Body> {+ let f = In(a);+ let s = validate(&f).ok_or(Error::Record(crate::import::Unsupported::Invalid("flat arrays")))?;+ let b = run("BrepFromFlat", |k| Ok(brep_from_flat(k, &f, &s)))??;+ Ok(Body::new(b))+}++fn brep_from_flat(k: &mut Kernel, f: &In<'_>, s: &Shape) -> Result<Brep> {+ let mut data = flat_to_brep_data(k, f, s)?;+ // no heal for B-reps SMLib wrote+ let trusted = f.i(SOURCE).first() == Some(&1);+ data.set_healer_version(if trusted { HEALER_VERSION } else { HEALER_VERSION - 2 });+ let mut b = Brep::new_with_infinite_region().map_err(sc("SmBrep::SmBrep"))?;+ let mut store = AttributeStore::default();+ let mut records = NotifyRecords::new();+ let next_key = (data.uv_curves.len() + data.curves_3d.len() + data.surfaces.len()) as u64 + 1;+ let mut env = TopologyEnv { all_attributes: &[], attributes: &mut store, key_of: &key_of, records: &mut records, next_key };+ let options = MakeTopologyOptions {+ make_uv_trim_curves: false,+ add_analytics: false,+ force_same_tol: true,+ check_uv_trim_curves: false,+ always_heal: false,+ healer_enabled: true,+ };+ make_topology_from_data(k, &mut b, &mut data, &mut env, options).map_err(sc("SmBrep::MakeTopologyFromData"))?;+ put_enclosing_shells_first(k, &mut b)?;+ Ok(b)+}++/// The most `SmShell::IsInnerShellOf` calls one conversion makes; a body that would need more+/// is refused instead of ray casting without end.+const MAX_CONTAINMENT_TESTS: usize = 1 << 16;++/// `PutEnclosingShellsFirst` (capi `smlib_flat.cpp`): SMLib takes the first shell of every region+/// but the infinite one as the shell that encloses the region, the others lying inside it+/// (`SmBrep::AssertValid` test 12). The arrays may list a region's shells in any order, so the one+/// that encloses all the others is put first, decided by `SmShell::IsInnerShellOf`+/// ([`shell::is_inner_shell_of`]). Candidates are the closed face-use shells whose bounding box+/// can be computed, largest box first (a stable sort: equal boxes keep the arrays' order). Only+/// `SM_TRUE` counts as inside: `SM_FALSE` and `SM_UNSURE` rule the candidate out, as the capi's+/// `== TRUE`, and a region where no candidate is shown to enclose the others keeps its order.+/// solidcore errors the C++ has no counterpart for (a call without a port, a dangling id) refuse+/// the conversion, as does a body needing more than [`MAX_CONTAINMENT_TESTS`] containment tests.+fn put_enclosing_shells_first(k: &mut Kernel, b: &mut Brep) -> Result<()> {+ use solidcore::query::face::p1::calculate_shell_bounding_box;+ let infinite = b.infinite_region();+ let mut tests = 0usize;+ for r in bl::regions(b, None).map_err(sc("GetRegions"))? {+ if Some(r) == infinite {+ continue;+ }+ let shells = b.region(r).map_err(sc("GetShells"))?.shells.clone();+ if shells.len() < 2 {+ continue;+ }+ let mut candidates: Vec<(f64, ShellId)> = Vec::new();+ for &s in &shells {+ let rec = b.shell(s).map_err(sc("GetShells"))?;+ if !rec.is_faceuse_shell() || !rec.is_closed(b, s).map_err(sc("SmShell::IsClosed"))? {+ continue;+ }+ match calculate_shell_bounding_box(k, b, s, false) {+ Ok(bx) => {+ let size = bx.size();+ candidates.push((size.x * size.y * size.z, s));+ }+ Err(e) if e.is_unported() => return Err(sc("SmShell::CalculateBoundingBox")(e)),+ // != SM_SUCCESS: not a candidate+ Err(_) => {}+ }+ }+ // stable: equal boxes keep the arrays' order+ candidates.sort_by(|a, c| c.0.partial_cmp(&a.0).unwrap_or(std::cmp::Ordering::Equal));+ for &(_, candidate) in &candidates {+ let mut encloses = true;+ for &s in &shells {+ if s == candidate {+ continue;+ }+ tests += 1;+ if tests > MAX_CONTAINMENT_TESTS {+ return Err(bad("too many shells to order (SmShell::IsInnerShellOf)"));+ }+ if shell::is_inner_shell_of(k, b, s, Some(candidate)).map_err(sc("SmShell::IsInnerShellOf"))? != shell::SM_TRUE {+ encloses = false;+ break;+ }+ }+ if encloses {+ // SmRegion::SetList(candidate): the circular list now starts at it+ let list = &mut b.region_mut(r).map_err(sc("SmRegion::SetList"))?.shells;+ if let Some(at) = list.iter().position(|&s| s == candidate) {+ list.rotate_left(at);+ }+ break;+ }+ }+ }+ Ok(())+}diff --git a/crates/smlib/src/core/convert_tests.rs b/crates/smlib/src/core/convert_tests.rsnew file mode 100644index 0000000000..c2754d75ca--- /dev/null+++ b/crates/smlib/src/core/convert_tests.rs@@ -0,0 +1,752 @@+//! solidcore's primitives through the flat arrays: each exports to a valid record of the right+//! volume, the record comes back to an equal body, and (with SMLib built) the arrays are the C+++//! kernel's own. A body with a sealed void crosses with each region's enclosing shell first,+//! whatever order its arrays list the shells in (the capi's `PutEnclosingShellsFirst`).++use std::f64::consts::PI;++use solidcraft_geom::brep as b;++use super::boolean::boolean;+use super::{Body, from_arrays, make_box, make_cone, make_cylinder, make_sphere, make_torus, to_arrays, volume};+use crate::BooleanOp;+use crate::export::native;+use crate::import::{self, Arrays};++/// A primitive: solidcore's body and its analytic volume.+struct Case {+ body: Body,+ volume: f64,+}++fn case(name: &str) -> Case {+ let (body, volume) = match name {+ "box" => (make_box([1.0, -2.0, 3.0], [10.0, 20.0, 30.0]), 6000.0),+ "cylinder" => (make_cylinder([1.0, 2.0, -3.0], 5.0, 12.0), PI * 25.0 * 12.0),+ "sphere" => (make_sphere([1.0, 2.0, 3.0], 7.0), 4.0 / 3.0 * PI * 343.0),+ "cone" => (make_cone([0.0, 1.0, 2.0], 6.0, 0.0, 9.0), PI * 36.0 * 9.0 / 3.0),+ "frustum" => (make_cone([0.0, 1.0, 2.0], 6.0, 2.0, 9.0), PI * 9.0 / 3.0 * (36.0 + 12.0 + 4.0)),+ "torus" => (make_torus([1.0, -1.0, 0.5], 10.0, 3.0), 2.0 * PI * PI * 10.0 * 9.0),+ _ => panic!("{name}"),+ };+ Case { body: body.unwrap(), volume }+}++fn rel(a: f64, b: f64) -> f64 {+ (a - b).abs() / b.abs()+}++/// The record of solidcore's arrays, validated and its geometry checked.+fn record(a: &Arrays) -> b::Brep {+ let (rec, _) = native(a).unwrap();+ rec.validate().unwrap();+ rec.check_geometry().unwrap();+ rec+}++/// Every number in `a` within `tol` (relative past 1) of `b`'s, everything else equal.+fn close(a: &serde_json::Value, b: &serde_json::Value, tol: f64, at: &str) {+ use serde_json::Value as V;+ match (a, b) {+ (V::Number(x), V::Number(y)) => {+ let (x, y) = (x.as_f64().unwrap(), y.as_f64().unwrap());+ assert!((x - y).abs() <= tol * x.abs().max(1.0), "{at}: {x} vs {y}");+ }+ (V::Array(x), V::Array(y)) => {+ assert_eq!(x.len(), y.len(), "{at}: length");+ for (i, (x, y)) in x.iter().zip(y).enumerate() {+ close(x, y, tol, &format!("{at}[{i}]"));+ }+ }+ (V::Object(x), V::Object(y)) => {+ assert_eq!(x.keys().collect::<Vec<_>>(), y.keys().collect::<Vec<_>>(), "{at}: keys");+ for (k, x) in x {+ close(x, &y[k], tol, &format!("{at}.{k}"));+ }+ }+ _ => assert_eq!(a, b, "{at}"),+ }+}++/// to_arrays gives a record that validates and whose geometry checks.+fn exports(name: &str) {+ record(&to_arrays(&case(name).body).unwrap());+}++/// solidcore's body measures its analytic volume.+fn measures(name: &str) {+ let c = case(name);+ let v = volume(&c.body, 1e-8).unwrap();+ assert!(rel(v, c.volume) < 1e-9, "{name}: solidcore volume {v} vs {}", c.volume);+}++/// record -> arrays -> from_arrays -> to_arrays -> record is the record, the volume exact.+fn round_trips(name: &str) {+ let c = case(name);+ let rec = record(&to_arrays(&c.body).unwrap());+ let back = from_arrays(&import::arrays(&rec, true).unwrap()).unwrap();+ let again = record(&to_arrays(&back).unwrap());+ close(&serde_json::to_value(&rec).unwrap(), &serde_json::to_value(&again).unwrap(), 1e-12, name);+ let v = volume(&back, 1e-8).unwrap();+ assert!(rel(v, c.volume) < 1e-9, "{name}: {v} vs {}", c.volume);+}++/// The C++ kernel's arrays of the same primitive: every id, ints exact, reals within 1e-12.+#[cfg(feature = "native")]+fn matches_cpp(name: &str) {+ use crate::flat::{TOLERANCE, VERTEX_TOLERANCE, WIRE_EDGE_NURBS_FORM};+ use crate::{Brep, ffi};+ // built by the C API whichever kernel is in force+ crate::init().unwrap();+ let cpp = match name {+ "box" => ffi::make_box(&[1.0, -2.0, 3.0], &[10.0, 20.0, 30.0]),+ "cylinder" => ffi::make_cylinder(&[1.0, 2.0, -3.0], 5.0, 12.0),+ "sphere" => ffi::make_sphere(&[1.0, 2.0, 3.0], 7.0),+ "cone" => ffi::make_cone(&[0.0, 1.0, 2.0], 6.0, 0.0, 9.0),+ "frustum" => ffi::make_cone(&[0.0, 1.0, 2.0], 6.0, 2.0, 9.0),+ "torus" => ffi::make_torus(&[1.0, -1.0, 0.5], 10.0, 3.0),+ _ => panic!("{name}"),+ }+ .map(Brep::made)+ .unwrap();+ let flat = cpp.export().unwrap();+ let ours = to_arrays(&case(name).body).unwrap();+ for id in 1..=WIRE_EDGE_NURBS_FORM {+ assert_eq!(ours.ints.get(&id).unwrap(), &flat.get_i64(id).unwrap(), "{name}: int array {id}");+ }+ for id in TOLERANCE..=VERTEX_TOLERANCE {+ let (a, b) = (ours.reals.get(&id).unwrap(), flat.get_f64(id).unwrap());+ assert_eq!(a.len(), b.len(), "{name}: real array {id} length");+ for (i, (x, y)) in a.iter().zip(&b).enumerate() {+ assert!((x - y).abs() <= 1e-12 * x.abs().max(1.0), "{name}: real array {id}[{i}]: {x} vs {y}");+ }+ }+}++/// The record of solidcore's arrays, built in the C++ kernel, measures the analytic volume.+#[cfg(feature = "native")]+fn record_measures_in_cpp(name: &str) {+ let c = case(name);+ let rec = record(&to_arrays(&c.body).unwrap());+ let v = crate::Brep::from_record(&rec, true).unwrap().volume(1e-8).unwrap();+ assert!(rel(v, c.volume) < 1e-9, "{name}: {v} vs {}", c.volume);+}++macro_rules! primitive {+ ($m:ident, $name:literal $(, volume: $vol:meta)? $(, round_trip: $rt:meta)?) => {+ mod $m {+ #[test]+ fn exports_a_valid_record() {+ super::exports($name);+ }+ #[test]+ $(#[$vol])?+ fn measures_its_volume() {+ super::measures($name);+ }+ #[test]+ $(#[$rt])?+ fn round_trips_through_the_record() {+ super::round_trips($name);+ }+ #[cfg(feature = "native")]+ #[test]+ fn its_record_measures_in_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ super::record_measures_in_cpp($name);+ }+ #[cfg(feature = "native")]+ #[test]+ fn arrays_match_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ super::matches_cpp($name);+ }+ }+ };+}++primitive!(box_, "box");+primitive!(cylinder, "cylinder");+primitive!(sphere, "sphere");+primitive!(cone, "cone");+primitive!(frustum, "frustum");+primitive!(torus, "torus");++#[test]+fn hostile_arrays_are_refused() {+ let c = case("box");+ let good = to_arrays(&c.body).unwrap();+ assert!(from_arrays(&Arrays::default()).is_err());+ for id in good.ints.keys().copied().collect::<Vec<_>>() {+ let mut a = good.clone();+ if let Some(v) = a.ints.get_mut(&id) {+ v.push(7);+ }+ let _ = from_arrays(&a);+ let mut a = good.clone();+ if let Some(v) = a.ints.get_mut(&id).and_then(|v| v.first_mut()) {+ *v = i64::MAX;+ }+ let _ = from_arrays(&a);+ }+ for id in good.reals.keys().copied().collect::<Vec<_>>() {+ let mut a = good.clone();+ if let Some(v) = a.reals.get_mut(&id).and_then(|v| v.first_mut()) {+ *v = f64::NAN;+ assert!(from_arrays(&a).is_err(), "NaN in {id}");+ }+ }+}++/// `GetOrCreateGwNurbPointer` on a parabola: the one with its NURB gives it; one built over an+/// interval too small for two end tangents to cross has none and makes none, an error naming+/// `MakeNurb`.+#[test]+fn a_parabola_gives_its_nurb_or_says_it_cannot() {+ use solidcore::curve::curve::Curve;+ use solidcore::curve::parabola::Parabola;+ use solidcore::geom::extent1d::Extent1d;+ use solidcore::geom::vector3d::{Point3, Vec3};+ let (x, y) = (Vec3::new(1.0, 0.0, 0.0), Vec3::new(0.0, 1.0, 0.0));+ let part = |lo: f64, hi: f64| -> crate::Result<bool> {+ let c = Curve::from(Parabola::new(Point3::new(0.0, 0.0, 0.0), x, y, Extent1d::from_min_max(lo, hi), 1.0, 3));+ let k = solidcore::kernel::Kernel::default();+ Ok(super::convert::bspline_curve_part(&k, &c)?.is_some_and(|b| b.gw_nurb().is_some()))+ };+ assert_eq!(part(-1.0, 1.0), Ok(true));+ let none = part(0.5, 0.5);+ assert!(matches!(&none, Err(e) if e.to_string().contains("MakeNurb")), "{none:?}");+}++/// `Validate` against the C++ one: each array of each body grown, emptied and given hostile values.+/// What ours refuses the C++ kernel does not build, and what the C++ kernel refuses with+/// `SM_ERR_INVALID_INPUT`, its `Validate`'s answer (its build can answer it too), ours does not build.+#[cfg(feature = "native")]+#[test]+fn validate_refuses_what_the_cpp_kernel_refuses() {+ let _cpp = crate::route::on_cpp();+ /// `SM_ERR_INVALID_INPUT`.+ const INVALID_INPUT: i32 = 1007;+ use crate::flat::Flat;+ use crate::{Brep, Error, ffi};+ crate::init().unwrap();+ let plate = ffi::make_box(&[0.0; 3], &[40.0, 30.0, 5.0]).unwrap();+ let rod = ffi::make_cylinder(&[20.0, 15.0, -1.0], 6.0, 7.0).unwrap();+ let cone = ffi::make_cone(&[0.0, 1.0, 2.0], 6.0, 2.0, 9.0).unwrap();+ let bodies = [+ ("holed plate", Brep::made(ffi::ops::boolean(&plate, &rod, ffi::ops::BOOLEAN_SUBTRACT).unwrap())),+ ("frustum", Brep::made(cone)),+ ("sphere", Brep::made(ffi::make_sphere(&[1.0, 2.0, 3.0], 7.0).unwrap())),+ ("torus", Brep::made(ffi::make_torus(&[1.0, -1.0, 0.5], 10.0, 3.0).unwrap())),+ ];+ let (mut compared, mut refusals) = (0usize, 0usize);+ for (name, body) in &bodies {+ let good = body.cpp_arrays().unwrap();+ let mut hostile: Vec<(String, Arrays)> = Vec::new();+ for (id, v) in &good.ints {+ let mut grown = good.clone();+ grown.ints.get_mut(id).unwrap().push(1);+ hostile.push((format!("int {id} grown"), grown));+ let mut none = good.clone();+ none.ints.get_mut(id).unwrap().clear();+ hostile.push((format!("int {id} emptied"), none));+ for at in [0, v.len().saturating_sub(1)] {+ for x in [-1, 0, 1, 2, 7, 1_000_000, i64::MAX, i64::MIN] {+ if v.get(at).is_some_and(|y| *y != x) {+ let mut a = good.clone();+ a.ints.get_mut(id).unwrap()[at] = x;+ hostile.push((format!("int {id}[{at}] = {x}"), a));+ }+ }+ }+ }+ for (id, v) in &good.reals {+ let mut grown = good.clone();+ grown.reals.get_mut(id).unwrap().push(1.0);+ hostile.push((format!("real {id} grown"), grown));+ let mut none = good.clone();+ none.reals.get_mut(id).unwrap().clear();+ hostile.push((format!("real {id} emptied"), none));+ for at in [0, v.len().saturating_sub(1)] {+ for x in [0.0, -1.0, 2.0, 1e10, -1e-13, f64::NAN, f64::INFINITY] {+ if !v.is_empty() {+ let mut a = good.clone();+ a.reals.get_mut(id).unwrap()[at] = x;+ hostile.push((format!("real {id}[{at}] = {x}"), a));+ }+ }+ }+ }+ for (what, a) in hostile {+ let cpp = Flat::from_arrays(&a).unwrap().import().map(|_| ());+ let cpp_refused = cpp == Err(Error::Status(INVALID_INPUT));+ let ours = super::convert::validate_refuses(&a);+ compared += 1;+ refusals += usize::from(ours);+ assert!(!(ours && cpp.is_ok()), "{name}, {what}: refused here, built in C++");+ assert!(!(cpp_refused && !ours && from_arrays(&a).is_ok()), "{name}, {what}: refused in C++, built here");+ }+ }+ assert!(compared > 500 && refusals > 200, "{compared} compared, {refusals} refused");+}++/// The C++ kernel's own box arrays (what `Brep::core` converts) build in solidcore.+#[cfg(feature = "native")]+#[test]+fn a_cpp_box_comes_into_solidcore() {+ let _cpp = crate::route::on_cpp();+ crate::init().unwrap();+ let cpp = crate::ffi::make_box(&[1.0, -2.0, 3.0], &[10.0, 20.0, 30.0]).map(crate::Brep::made).unwrap();+ let body = from_arrays(&cpp.cpp_arrays().unwrap()).unwrap();+ let v = volume(&body, 1e-8).unwrap();+ assert!(rel(v, 6000.0) < 1e-9, "{v}");+ record(&to_arrays(&body).unwrap());+}++/// Each edge's and vertex's tolerance crosses the kernels as it is. One box edge given eight times+/// the box's tolerance, in arrays whose TOLERANCE is the largest (as the C++ kernel writes them),+/// keeps it round after round, and the B-rep and every other edge and vertex keep the box's. Every+/// crossing used to give every entity the largest, so a chain of blends on a mixed route grew the+/// whole body's tolerance fourfold per blend (fillets/2341).+#[test]+fn tolerances_cross_the_arrays_per_entity() {+ #[cfg(feature = "native")]+ let _cpp = crate::route::on_cpp();+ use crate::flat::{EDGE_TOLERANCE, TOLERANCE, VERTEX_TOLERANCE};+ let mut a = to_arrays(&case("box").body).unwrap();+ let base = a.reals[&TOLERANCE][0];+ assert!(a.reals[&EDGE_TOLERANCE].iter().chain(&a.reals[&VERTEX_TOLERANCE]).all(|&t| t == base), "{a:?}");+ a.reals.get_mut(&EDGE_TOLERANCE).unwrap()[0] = 8.0 * base;+ a.reals.get_mut(&TOLERANCE).unwrap()[0] = 8.0 * base;+ for round in 0..3 {+ let body = from_arrays(&a).unwrap();+ assert_eq!(body.0.lock().unwrap().tolerance(), base / 2.0, "round {round}");+ a = to_arrays(&body).unwrap();+ assert_eq!(a.reals[&TOLERANCE], [base], "round {round}");+ let edges = &a.reals[&EDGE_TOLERANCE];+ assert_eq!(edges[0], 8.0 * base, "round {round}");+ assert!(edges[1..].iter().chain(&a.reals[&VERTEX_TOLERANCE]).all(|&t| t == base), "round {round}: {a:?}");+ // and through the C++ kernel, which keeps them too+ #[cfg(feature = "native")]+ {+ let cpp = crate::flat::Flat::from_arrays(&a).unwrap().import().unwrap().cpp_arrays().unwrap();+ assert_eq!((&cpp.reals[&EDGE_TOLERANCE], &cpp.reals[&VERTEX_TOLERANCE]), (edges, &a.reals[&VERTEX_TOLERANCE]), "round {round}");+ a = cpp;+ }+ }+}++/// A 20 mm box minus a centred 10 mm box: a sealed void, so its solid region has two shells.+fn sealed_void() -> Body {+ boolean(&make_box([-10.0; 3], [20.0; 3]).unwrap(), &make_box([-5.0; 3], [10.0; 3]).unwrap(), BooleanOp::Subtract).unwrap().unwrap()+}++/// 20³ − 10³.+const SEALED_VOID_VOLUME: f64 = 8000.0 - 1000.0;++/// Each bounded region's shells, as each shell's reach: the largest |coordinate| of its vertices+/// (10 for the 20 mm box, 5 for the 10 mm one).+fn reaches(rec: &b::Brep) -> Vec<Vec<f64>> {+ let reach = |s: u32| {+ let Some(b::Shell::Faces { faces, .. }) = rec.shells.get(s as usize) else { panic!("shell {s}") };+ let mut r = 0.0f64;+ for f in faces {+ for l in &rec.faces[f.face as usize].loops {+ let b::Loop::Edges { edges } = l else { continue };+ for e in edges {+ for &v in &rec.edges[e.edge as usize].vertices {+ r = rec.vertices[v as usize].point.iter().fold(r, |r, c| r.max(c.abs()));+ }+ }+ }+ }+ r+ };+ rec.regions.iter().skip(1).map(|r| r.shells.iter().map(|&s| reach(s)).collect()).collect()+}++/// The sealed void's record: the solid region lists the outer box first, then the void's box;+/// the void region its box alone.+fn outer_first(a: &Arrays, at: &str) {+ let mut got = reaches(&record(a));+ got.sort_by_key(|x| std::cmp::Reverse(x.len()));+ assert_eq!(got, [vec![10.0, 5.0], vec![5.0]], "{at}");+}++/// The arrays with every region's shells listed in reverse: each shell's block (its counts and+/// its face uses) moved, nothing else touched.+fn shells_reversed(a: &Arrays) -> Arrays {+ use crate::flat::{FACEUSE_FACE, FACEUSE_ORIENTATION, REGION_SHELL_COUNT, SHELL_FACEUSE_COUNT, SHELL_POINT_TYPE, SHELL_WIRE_EDGE_COUNT};+ let mut p = a.clone();+ let blocks = [SHELL_FACEUSE_COUNT, SHELL_WIRE_EDGE_COUNT, SHELL_POINT_TYPE, FACEUSE_FACE, FACEUSE_ORIENTATION];+ for id in blocks {+ p.ints.get_mut(&id).unwrap().clear();+ }+ let (mut shell, mut fu) = (0usize, 0usize);+ for &n in &a.ints[®ION_SHELL_COUNT] {+ let mut region = Vec::new();+ for _ in 0..n {+ let uses = usize::try_from(a.ints[&SHELL_FACEUSE_COUNT][shell]).unwrap();+ region.push((shell, fu..fu + uses));+ shell += 1;+ fu += uses;+ }+ for (s, uses) in region.into_iter().rev() {+ for id in [SHELL_FACEUSE_COUNT, SHELL_WIRE_EDGE_COUNT, SHELL_POINT_TYPE] {+ let v = a.ints[&id][s];+ p.ints.get_mut(&id).unwrap().push(v);+ }+ for id in [FACEUSE_FACE, FACEUSE_ORIENTATION] {+ p.ints.get_mut(&id).unwrap().extend_from_slice(&a.ints[&id][uses.clone()]);+ }+ }+ }+ assert_ne!(p.ints, a.ints, "nothing to reverse");+ p+}++/// solidcore's sealed void exports with its outer shell first, comes back through the arrays+/// with it first, and keeps its volume.+#[test]+fn a_sealed_void_crosses_the_arrays_outer_shell_first() {+ let body = sealed_void();+ let v = volume(&body, 1e-9).unwrap();+ assert!(rel(v, SEALED_VOID_VOLUME) < 1e-9, "{v}");+ let a = to_arrays(&body).unwrap();+ outer_first(&a, "export");+ let back = from_arrays(&import::arrays(&record(&a), true).unwrap()).unwrap();+ outer_first(&to_arrays(&back).unwrap(), "round trip");+ let v = volume(&back, 1e-9).unwrap();+ assert!(rel(v, SEALED_VOID_VOLUME) < 1e-9, "round trip: {v}");+}++/// Arrays listing the solid region's void shell before the box around it import with the box+/// first (SMLib takes a region's first shell as its enclosing one), the volume unchanged.+#[test]+fn shells_listed_inner_first_import_outer_first() {+ let a = shells_reversed(&to_arrays(&sealed_void()).unwrap());+ let back = from_arrays(&a).unwrap();+ outer_first(&to_arrays(&back).unwrap(), "inner first");+ let v = volume(&back, 1e-9).unwrap();+ assert!(rel(v, SEALED_VOID_VOLUME) < 1e-9, "inner first: {v}");+}++/// The C++ kernel's sealed void: solidcore imports its arrays with the outer shell first, in+/// either shell order, at the C++ kernel's volume, and the C++ kernel reads solidcore's arrays+/// (either order) back as a body that passes its checks at that volume.+#[cfg(feature = "native")]+#[test]+fn a_sealed_void_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ use crate::{Brep, ffi};+ crate::init().unwrap();+ let make = |o: f64, s: f64| ffi::make_box(&[o; 3], &[s; 3]).map(Brep::made).unwrap();+ let (outer, inner) = (make(-10.0, 20.0), make(-5.0, 10.0));+ let cpp = Brep::made(ffi::ops::boolean(outer.cpp().unwrap(), inner.cpp().unwrap(), ffi::ops::BOOLEAN_SUBTRACT).unwrap());+ let theirs = ffi::volume(cpp.cpp().unwrap(), 1e-9).unwrap();+ assert!(rel(theirs, SEALED_VOID_VOLUME) < 1e-9, "C++ {theirs}");+ let arrays = cpp.cpp_arrays().unwrap();+ outer_first(&arrays, "C++ export");+ for (at, a) in [("C++ arrays", arrays.clone()), ("C++ arrays, inner first", shells_reversed(&arrays))] {+ let body = from_arrays(&a).unwrap();+ outer_first(&to_arrays(&body).unwrap(), at);+ let v = volume(&body, 1e-9).unwrap();+ assert!(rel(v, theirs) < 1e-9, "{at}: solidcore {v} vs C++ {theirs}");+ }+ let ours = to_arrays(&sealed_void()).unwrap();+ for (at, a) in [("solidcore arrays", ours.clone()), ("solidcore arrays, inner first", shells_reversed(&ours))] {+ let h = crate::flat::Flat::from_arrays(&a).unwrap().import().unwrap();+ let v = ffi::volume(h.cpp().unwrap(), 1e-9).unwrap();+ assert!(rel(v, theirs) < 1e-9, "{at}: C++ {v} vs {theirs}");+ let mut buf = vec![0u8; 1 << 16];+ let (len, failures) = ffi::check::check(h.cpp().unwrap(), 2, &mut buf).unwrap();+ assert_eq!(failures, 0, "{at}: {}", String::from_utf8_lossy(&buf[..len]));+ outer_first(&h.cpp_arrays().unwrap(), &format!("{at}, C++ export"));+ }+}++/// C++ bodies through solidcore and back. Three crossings of the same C++ arrays are held equal,+/// ints exactly and reals to 1e-12 (the record too, where the record can say it):+/// - the C++ kernel's own: its import of them, exported again;+/// - solidcore's: `from_arrays`, then `to_arrays`;+/// - both: solidcore's arrays imported by the C++ kernel and exported again.+///+/// The first is the reference, not the arrays that went in: a crossing itself moves a few reals on+/// the C++ kernel too (UV trims made at export, about 1e-7 on a shelled box), so those are held to+/// the arrays that went in only at [`FIRST_CROSSING`]. Tolerances are excepted: they cross on+/// purpose as each entity's own (`own_tolerances`, TOLERANCE as twice the B-rep's) where the C+++/// export writes the largest over them all, so that a body does not grow its tolerance at every+/// crossing (`tolerances_cross_the_arrays_per_entity`); on a body an operation made the numbers+/// cannot agree. So is EXTENT, the bounding box padded by those tolerances.+#[cfg(feature = "native")]+mod cpp_round_trip {+ use serde_json::Value;+ use solidcraft_geom::brep as b;++ use super::{close, from_arrays, native, rel, to_arrays, volume};+ use crate::flat::{self, EDGE_TOLERANCE, EXTENT, Flat, TOLERANCE, VERTEX_TOLERANCE};+ use crate::import::Arrays;+ use crate::sweeps::{Curve, DraftCorner, SweepFrame};+ use crate::{Brep, ffi};++ const PICK_TOL: f64 = 1e-6;++ /// How far any crossing, the C++ kernel's own included, may move a real of the arrays that+ /// went in.+ const FIRST_CROSSING: f64 = 1e-6;++ fn cpp_box(o: [f64; 3], s: [f64; 3]) -> Brep {+ crate::init().unwrap();+ Brep::made(ffi::make_box(&o, &s).unwrap())+ }++ fn cpp_cylinder(o: [f64; 3], r: f64, h: f64) -> Brep {+ crate::init().unwrap();+ Brep::made(ffi::make_cylinder(&o, r, h).unwrap())+ }++ fn cut(a: &Brep, b: &Brep) -> Brep {+ Brep::made(ffi::ops::boolean(a.cpp().unwrap(), b.cpp().unwrap(), ffi::ops::BOOLEAN_SUBTRACT).unwrap())+ }++ /// `f` with the sweeps on the C++ kernel, whatever the choice.+ fn on_cpp(f: impl FnOnce() -> crate::Result<Brep>) -> Brep {+ crate::init().unwrap();+ crate::sweeps::ON_CPP.with(|c| c.set(true));+ let r = f();+ crate::sweeps::ON_CPP.with(|c| c.set(false));+ r.unwrap()+ }++ /// The record as JSON, every `tolerance` (the B-rep's, an edge's, a vertex's) gone.+ fn without_tolerances(rec: &b::Brep) -> Value {+ fn strip(v: &mut Value) {+ match v {+ Value::Object(m) => {+ m.remove("tolerance");+ m.values_mut().for_each(strip);+ }+ Value::Array(a) => a.iter_mut().for_each(strip),+ _ => {}+ }+ }+ let mut v = serde_json::to_value(rec).unwrap();+ strip(&mut v);+ v+ }++ /// `want` and `got` agree: ints exact, reals within `tol`, tolerances and EXTENT excepted.+ fn same_arrays(at: &str, want: &Arrays, got: &Arrays, tol: f64) {+ assert_eq!(want.ints.keys().collect::<Vec<_>>(), got.ints.keys().collect::<Vec<_>>(), "{at}: int arrays");+ for (id, v) in &want.ints {+ assert_eq!(v, &got.ints[id], "{at}: int array {id}");+ }+ assert_eq!(want.reals.keys().collect::<Vec<_>>(), got.reals.keys().collect::<Vec<_>>(), "{at}: real arrays");+ for (id, v) in &want.reals {+ if [TOLERANCE, EXTENT, EDGE_TOLERANCE, VERTEX_TOLERANCE].contains(id) {+ assert_eq!(v.len(), got.reals[id].len(), "{at}: real array {id} length");+ continue;+ }+ let (x, y) = (serde_json::to_value(v).unwrap(), serde_json::to_value(&got.reals[id]).unwrap());+ close(&x, &y, tol, &format!("{at}: real array {id}"));+ }+ }++ /// [`same_arrays`], and their records the same, valid and with tolerances excepted.+ fn same_records(at: &str, want: &Arrays, got: &Arrays, tol: f64) -> b::Brep {+ same_arrays(at, want, got, tol);+ let ((w, _), (g, _)) = (native(want).unwrap(), native(got).unwrap());+ w.validate().unwrap();+ g.validate().unwrap();+ close(&without_tolerances(&w), &without_tolerances(&g), tol, at);+ w+ }++ /// The three crossings of `theirs`: the C++ kernel's own, solidcore's, and solidcore's arrays+ /// back through the C++ kernel.+ fn crossings(theirs: &Arrays) -> [Arrays; 3] {+ let own = Flat::from_arrays(theirs).unwrap().import().unwrap().cpp_arrays().unwrap();+ let ours = to_arrays(&from_arrays(theirs).unwrap()).unwrap();+ let back = Flat::from_arrays(&ours).unwrap().import().unwrap().cpp_arrays().unwrap();+ [own, ours, back]+ }++ /// Arrays the record cannot say (wire and point shells): the crossings' arrays only.+ fn crosses_as_arrays(name: &str, theirs: &Arrays) {+ let [own, ours, back] = crossings(theirs);+ same_arrays(&format!("{name}, solidcore's arrays"), &own, &ours, 1e-12);+ same_arrays(&format!("{name}, back through C++"), &own, &back, 1e-12);+ }++ /// `cpp` across: returns its record, for the case to say what it holds.+ fn crosses(name: &str, cpp: &Brep) -> b::Brep {+ let theirs = cpp.cpp_arrays().unwrap();+ let [own, ours, back] = crossings(&theirs);+ same_records(&format!("{name}, solidcore's arrays"), &own, &ours, 1e-12);+ same_records(&format!("{name}, back through C++"), &own, &back, 1e-12);+ same_records(&format!("{name}, the arrays that went in"), &theirs, &ours, FIRST_CROSSING)+ }++ /// [`crosses`], and solidcore measures the C++ kernel's volume.+ fn crosses_with_volume(name: &str, cpp: &Brep) -> b::Brep {+ let rec = crosses(name, cpp);+ let body = from_arrays(&cpp.cpp_arrays().unwrap()).unwrap();+ let (v, want) = (volume(&body, 1e-8).unwrap(), ffi::volume(cpp.cpp().unwrap(), 1e-8).unwrap());+ assert!(rel(v, want) < 1e-7, "{name}: solidcore {v} vs C++ {want}");+ rec+ }++ fn has_face(rec: &b::Brep, f: impl Fn(&b::Face) -> bool) -> bool {+ rec.faces.iter().any(f)+ }++ /// A 20 mm box with three edges at one corner rounded: rolling-ball faces and a corner patch,+ /// on an operation's tolerances.+ #[test]+ fn a_filleted_box() {+ let _cpp = crate::route::on_cpp();+ let a = cpp_box([0.0; 3], [20.0; 3]);+ let edges = [[10.0, 0.0, 0.0], [0.0, 10.0, 0.0], [0.0, 0.0, 10.0]];+ let f = Brep::made(ffi::ops::pick_op(ffi::ops::Pick::Fillet, a.cpp().unwrap(), &edges, PICK_TOL, 2.0).unwrap());+ let rec = crosses_with_volume("filleted box", &f);+ assert!(rec.faces.len() > 6, "{}", rec.faces.len());+ }++ /// A plate with a round hole: inner loops, and a cylinder face looking at its axis.+ #[test]+ fn a_holed_plate() {+ let _cpp = crate::route::on_cpp();+ let p = cut(&cpp_box([0.0; 3], [40.0, 30.0, 5.0]), &cpp_cylinder([20.0, 15.0, -1.0], 6.0, 7.0));+ let rec = crosses_with_volume("holed plate", &p);+ assert!(has_face(&rec, |f| f.loops.len() > 1), "no inner loop");+ }++ /// A square swept along a cubic B-spline path: B-spline walls that are nothing analytic.+ #[test]+ fn a_swept_nurbs_face() {+ let _cpp = crate::route::on_cpp();+ let c = [[-2.0, -2.0, 0.0], [2.0, -2.0, 0.0], [2.0, 2.0, 0.0], [-2.0, 2.0, 0.0]];+ let square: Vec<Curve> = (0..4).map(|i| Curve::Line { start: c[i], end: c[(i + 1) % 4] }).collect();+ let points = [[0.0, 0.0, 0.0, 1.0], [0.0, 10.0, 20.0, 1.0], [10.0, -10.0, 40.0, 1.0], [10.0, 0.0, 60.0, 1.0]];+ let path = [Curve::Nurbs { degree: 3, points: points.to_vec(), knots: vec![0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0] }];+ let s = on_cpp(|| Brep::sweep(&square, &path, SweepFrame::Follow, true));+ let rec = crosses_with_volume("swept square", &s);+ assert!(has_face(&rec, |f| matches!(f.surface, b::Surface::Spline { .. } | b::Surface::RationalSpline { .. })), "no NURBS face");+ }++ /// A cylinder sliced by a plane leaning 45 degrees: the cut's edge an ellipse.+ #[test]+ fn an_ellipse_edge() {+ let _cpp = crate::route::on_cpp();+ let cyl = cpp_cylinder([0.0, 0.0, -30.0], 5.0, 60.0);+ let (s, c) = std::f64::consts::FRAC_PI_4.sin_cos();+ // About y through the origin; the box's underside is the plane z = 0 turned.+ let turn = [[c, 0.0, s, 0.0], [0.0, 1.0, 0.0, 0.0], [-s, 0.0, c, 0.0], [0.0, 0.0, 0.0, 1.0]];+ let tool = Brep::made(ffi::transform(cpp_box([-50.0, -50.0, 0.0], [100.0; 3]).cpp().unwrap(), &turn).unwrap());+ let rec = crosses_with_volume("leaning cut", &cut(&cyl, &tool));+ assert!(rec.edges.iter().any(|e| matches!(e.curve, b::Curve::Ellipse { .. })), "no ellipse edge");+ }++ /// A 20 mm box with a 10 mm void sealed inside: two shells in the solid's region.+ #[test]+ fn a_sealed_void() {+ let _cpp = crate::route::on_cpp();+ let v = cut(&cpp_box([-10.0; 3], [20.0; 3]), &cpp_box([-5.0; 3], [10.0; 3]));+ let rec = crosses_with_volume("sealed void", &v);+ assert!(rec.regions.iter().any(|r| r.shells.len() == 2), "{:?}", rec.regions);+ assert!(rec.regions.iter().any(|r| r.void), "{:?}", rec.regions);+ }++ /// One planar face, and an open extrusion: a sheet's shells, no solid.+ #[test]+ fn sheets() {+ let _cpp = crate::route::on_cpp();+ let c = [[0.0, 0.0, 0.0], [10.0, 0.0, 0.0], [10.0, 6.0, 0.0], [0.0, 6.0, 0.0]];+ let rect: Vec<Curve> = (0..4).map(|i| Curve::Line { start: c[i], end: c[(i + 1) % 4] }).collect();+ let rec = crosses("planar sheet", &on_cpp(|| Brep::planar_faces(&rect)));+ assert_eq!(rec.faces.len(), 1);+ let open = on_cpp(|| Brep::extrude(&rect, [0.0, 0.0, 1.0], 5.0, 0.0, DraftCorner::default(), false));+ let rec = crosses("open extrusion", &open);+ assert_eq!(rec.faces.len(), 4);+ }++ /// A C++ box's arrays with one wire edge of each kind (a line, a whole circle, a half ellipse,+ /// a cubic B-spline) and one point, each a shell of its own in the infinite region. The C API+ /// gives no body without a face (`take`), so these lie beside a box.+ fn box_with_wires_and_a_point() -> Arrays {+ let tau = std::f64::consts::TAU;+ let mut a = cpp_box([20.0; 3], [5.0; 3]).cpp_arrays().unwrap();+ let first_new = a.ints[&flat::VERTEX_POINT_TYPE].len() as i64;+ a.ints.get_mut(&flat::REGION_SHELL_COUNT).unwrap()[0] += 5;+ for (id, v) in+ [(flat::SHELL_FACEUSE_COUNT, [0, 0, 0, 0, 0]), (flat::SHELL_WIRE_EDGE_COUNT, [1, 1, 1, 1, 0]), (flat::SHELL_POINT_TYPE, [0, 0, 0, 0, 1])]+ {+ a.ints.get_mut(&id).unwrap().splice(1..1, v);+ }+ a.ints.insert(+ flat::WIRE_EDGE_CURVE_TYPE,+ [flat::CURVE_LINE, flat::CURVE_CIRCLE, flat::CURVE_ELLIPSE, flat::CURVE_NURBS].map(i64::from).to_vec(),+ );+ a.ints.insert(flat::WIRE_EDGE_VERTICES, [0, 1, 2, 2, 3, 4, 5, 6].map(|v| first_new + v).to_vec());+ a.ints.insert(flat::WIRE_EDGE_NURBS_VERTEX_COUNT, vec![4]);+ a.ints.insert(flat::WIRE_EDGE_NURBS_ORDER, vec![4]);+ let points = [[0.0, 0.0, 0.0], [10.0, 0.0, 0.0], [4.0, 0.0, 5.0], [3.0, 0.0, -5.0], [-3.0, 0.0, -5.0], [0.0, 9.0, 0.0], [9.0, 9.0, 3.0]];+ a.ints.get_mut(&flat::VERTEX_POINT_TYPE).unwrap().extend([1; 7]);+ a.reals.get_mut(&flat::VERTEX_POSITION).unwrap().extend(points.concat());+ let base = a.reals[&TOLERANCE][0];+ a.reals.get_mut(&VERTEX_TOLERANCE).unwrap().extend([base; 7]);+ let reals: [(i32, Vec<f64>); 17] = [+ (flat::SHELL_POINT_POSITION, vec![1.0, 2.0, 3.0]),+ (flat::WIRE_EDGE_RANGE, vec![0.0, 10.0, 0.0, tau, 0.0, std::f64::consts::PI, 0.0, 1.0]),+ (flat::WIRE_EDGE_LINE_ORIGIN, vec![0.0; 3]),+ (flat::WIRE_EDGE_LINE_DIRECTION, vec![1.0, 0.0, 0.0]),+ (flat::WIRE_EDGE_CIRCLE_CENTER, vec![0.0, 0.0, 5.0]),+ (flat::WIRE_EDGE_CIRCLE_AXIS, vec![0.0, 0.0, 1.0]),+ (flat::WIRE_EDGE_CIRCLE_REF_DIRECTION, vec![1.0, 0.0, 0.0]),+ (flat::WIRE_EDGE_CIRCLE_RADIUS, vec![4.0]),+ (flat::WIRE_EDGE_ELLIPSE_CENTER, vec![0.0, 0.0, -5.0]),+ (flat::WIRE_EDGE_ELLIPSE_AXIS, vec![0.0, 0.0, 1.0]),+ (flat::WIRE_EDGE_ELLIPSE_REF_DIRECTION, vec![1.0, 0.0, 0.0]),+ (flat::WIRE_EDGE_ELLIPSE_X_RADIUS, vec![3.0]),+ (flat::WIRE_EDGE_ELLIPSE_Y_RADIUS, vec![2.0]),+ (flat::WIRE_EDGE_NURBS_CVS, [points[5], [3.0, 12.0, 0.0], [6.0, 6.0, 2.0], points[6]].concat()),+ (flat::WIRE_EDGE_NURBS_KNOTS, vec![0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0]),+ (flat::WIRE_EDGE_NURBS_WEIGHTS, Vec::new()),+ (EXTENT, vec![-3.0, 0.0, -5.0, 25.0, 25.0, 25.0]),+ ];+ a.reals.extend(reals);+ a+ }++ /// Wire edges no face uses and a point shell. The record says no such shell from SMLib, so+ /// arrays only.+ #[test]+ fn wire_edges_and_a_point_shell() {+ let _cpp = crate::route::on_cpp();+ let theirs = Flat::from_arrays(&box_with_wires_and_a_point()).unwrap().import().unwrap().cpp_arrays().unwrap();+ assert_eq!(theirs.ints[&flat::WIRE_EDGE_CURVE_TYPE].len(), 4);+ assert_eq!(theirs.reals[&flat::SHELL_POINT_POSITION], [1.0, 2.0, 3.0]);+ crosses_as_arrays("wire edges and a point", &theirs);+ }++ /// Two boxes apart, united: two lumps.+ #[test]+ fn a_multi_lump_body() {+ let _cpp = crate::route::on_cpp();+ let (a, b) = (cpp_box([0.0; 3], [10.0; 3]), cpp_box([30.0, 0.0, 0.0], [5.0; 3]));+ let u = Brep::made(ffi::ops::boolean(a.cpp().unwrap(), b.cpp().unwrap(), ffi::ops::BOOLEAN_UNION).unwrap());+ let rec = crosses_with_volume("two lumps", &u);+ assert_eq!(ffi::ops::solid_count(u.cpp().unwrap()).unwrap(), 2);+ assert_eq!(rec.faces.len(), 12);+ }++ /// A rounded box shelled: faces on the offsets of its rounds, on the operation's tolerances.+ #[test]+ fn a_shelled_rounded_box() {+ let _cpp = crate::route::on_cpp();+ let a = cpp_box([0.0; 3], [20.0; 3]);+ let r = ffi::ops::pick_op(ffi::ops::Pick::Fillet, a.cpp().unwrap(), &[[10.0, 0.0, 0.0]], PICK_TOL, 2.0).unwrap();+ let s = Brep::made(ffi::ops::pick_op(ffi::ops::Pick::Shell, &r, &[[10.0, 10.0, 20.0]], PICK_TOL, -1.0).unwrap());+ crosses_with_volume("shelled rounded box", &s);+ }+}diff --git a/crates/smlib/src/core/dump.rs b/crates/smlib/src/core/dump.rsnew file mode 100644index 0000000000..84fc9d8840--- /dev/null+++ b/crates/smlib/src/core/dump.rs@@ -0,0 +1,132 @@+//! What a failing solidcore call leaves behind, and which one is running: `smlib_set_dump_dir` and+//! `smlib_current_call` for this kernel. While a folder is set, each call's B-rep inputs are+//! written to memory before it runs (it may edit them) and to files only if it fails:+//! `<n>-<call>.txt`, what failed, and `<n>-<call>-<input>.smb`, each input as a binary `.smb`, which+//! `Brep::read` reads back.++use std::path::PathBuf;+use std::sync::atomic::{AtomicU8, AtomicU64, AtomicUsize, Ordering};+use std::sync::{Mutex, PoisonError};++use solidcore::kernel::Kernel;+use solidcore::topology::Brep;++use crate::{Error, Result};++static DIR: Mutex<Option<PathBuf>> = Mutex::new(None);+static SEQUENCE: AtomicU64 = AtomicU64::new(0);+/// The inputs of the call running now, in the order it took them.+static INPUTS: Mutex<Vec<(&'static str, std::result::Result<Vec<u8>, String>)>> = Mutex::new(Vec::new());++/// Where failing calls leave their inputs; `None` stops it.+pub(crate) fn set_dir(dir: Option<PathBuf>) {+ *DIR.lock().unwrap_or_else(PoisonError::into_inner) = dir;+}++fn dumping() -> bool {+ DIR.lock().unwrap_or_else(PoisonError::into_inner).is_some()+}++/// A new call, with no inputs yet.+pub(super) fn begin() {+ if dumping() {+ INPUTS.lock().unwrap_or_else(PoisonError::into_inner).clear();+ }+}++/// `b` is an input of the running call, by the name `what`.+pub(crate) fn input(k: &Kernel, what: &'static str, b: &Brep) {+ if dumping() {+ let bytes = super::file::bytes(k, b, false).map_err(|e| e.to_string());+ INPUTS.lock().unwrap_or_else(PoisonError::into_inner).push((what, bytes));+ }+}++fn safe(call: &str) -> String {+ call.chars().map(|c| if c.is_ascii_alphanumeric() || c == '_' { c } else { '_' }).collect()+}++/// The running call failed: its inputs go to the folder. Failing to write them fails nothing else.+pub(super) fn failed(call: &str, why: &str) {+ let Some(dir) = DIR.lock().unwrap_or_else(PoisonError::into_inner).clone() else { return };+ let n = SEQUENCE.fetch_add(1, Ordering::Relaxed);+ let stem = format!("{n:06}-{}", safe(call));+ let mut text = format!("{call} -> {why}\nnumeric arguments are not recorded\n");+ for (what, bytes) in INPUTS.lock().unwrap_or_else(PoisonError::into_inner).drain(..) {+ match bytes {+ Ok(b) => {+ let name = format!("{stem}-{what}.smb");+ if let Err(e) = std::fs::write(dir.join(&name), b) {+ log::warn!(target: "smlib", "{name}: {e}");+ }+ text.push_str(&format!("input {what}: {name}\n"));+ }+ Err(e) => text.push_str(&format!("input {what}: could not be written: {e}\n")),+ }+ }+ if let Err(e) = std::fs::write(dir.join(format!("{stem}.txt")), text) {+ log::warn!(target: "smlib", "{stem}.txt: {e}");+ }+}++/// How a call's value reads: whether it is a refusal, for the calls that answer with one.+pub(crate) trait Answer {+ fn refusal(&self) -> Option<String> {+ None+ }+}++impl<T> Answer for Result<T> {+ fn refusal(&self) -> Option<String> {+ self.as_ref().err().map(Error::to_string)+ }+}++/// The values that are no refusal.+macro_rules! plain {+ ($($t:ty),* $(,)?) => { $(impl Answer for $t {})* };+}+plain!(+ (),+ bool,+ f64,+ usize,+ [usize; 3],+ ([f64; 3], [f64; 3]),+ Vec<u8>,+ Vec<[f64; 3]>,+ Brep,+ solidcore::geom::vector3d::Point3,+ crate::history::Raw,+ crate::MassProperties+);++impl<T> Answer for Option<T> {}++/// The longest call name [`current`] gives.+const NAME_MAX: usize = 96;+static NAME: [AtomicU8; NAME_MAX] = [const { AtomicU8::new(0) }; NAME_MAX];+static NAME_LEN: AtomicUsize = AtomicUsize::new(0);++/// `call` is running now (`None`: none is). One at a time, under the kernel's lock.+pub(super) fn set_current(call: Option<&str>) {+ NAME_LEN.store(0, Ordering::SeqCst);+ let Some(call) = call else { return };+ let bytes = call.as_bytes();+ let n = bytes.len().min(NAME_MAX);+ for (slot, b) in NAME.iter().zip(bytes) {+ slot.store(*b, Ordering::Relaxed);+ }+ NAME_LEN.store(n, Ordering::SeqCst);+}++/// The call running now. Takes no lock, for crash reports, so it may be cut short or mixed with the+/// next call's name if read just as one starts.+pub(crate) fn current() -> Option<String> {+ let n = NAME_LEN.load(Ordering::SeqCst);+ if n == 0 {+ return None;+ }+ let bytes: Vec<u8> = NAME.iter().take(n).map(|b| b.load(Ordering::Relaxed)).collect();+ Some(String::from_utf8_lossy(&bytes).into_owned())+}diff --git a/crates/smlib/src/core/file.rs b/crates/smlib/src/core/file.rsnew file mode 100644index 0000000000..2164ffee16--- /dev/null+++ b/crates/smlib/src/core/file.rs@@ -0,0 +1,60 @@+//! `.smb` files on solidcore (`smlib_brep_read`, `smlib_brep_write`): the B-rep's contents through+//! `SmApiReadBrepFromFile` and `SmApiWriteBrepToFile`, the file itself read and written here (the+//! library touches no files, so that it builds for the browser).++use std::path::Path;++use solidcore::geom::attribute::{AttributeStore, ObjectKey};+use solidcore::kernel::Kernel;+use solidcore::topology::api_files::{read_brep_from_file, write_brep_to_file};+use solidcore::topology::brep::p10::TopologyEnv;+use solidcore::topology::brep_data_write::FromBrepEnv;+use solidcore::topology::topology::NotifyRecords;+use solidcore::topology::{Brep, EdgeId, EdgeuseId, FaceId};++use super::convert::key_of;+use super::{Body, run, with_body};+use crate::{Error, Result};++/// Where the keys of a file's curves and surfaces start, clear of [`key_of`]'s entity keys.+const FILE_KEYS: u64 = 1 << 50;++fn io(what: &str, path: &Path, e: &std::io::Error) -> Error {+ Error::Solidcore(format!("{what} {}: {e}", path.display()))+}++/// The body in the file at `path`, ASCII or binary. Its UV trims are checked, not rebuilt, as the+/// C API reads them.+pub(crate) fn read(path: &Path, ascii: bool) -> Result<Body> {+ let data = std::fs::read(path).map_err(|e| io("reading", path, &e))?;+ let b = run("smlib_brep_read", |k| {+ let mut attributes = AttributeStore::default();+ let mut records = NotifyRecords::new();+ let mut env = TopologyEnv { all_attributes: &[], attributes: &mut attributes, key_of: &key_of, records: &mut records, next_key: FILE_KEYS };+ let mut b = read_brep_from_file(k, Some(data), ascii, false, &mut env)?;+ b.refresh_cached_topology();+ Ok(b)+ })?;+ Ok(Body::new(b))+}++/// `b` as the contents of a `.smb` file, ASCII or binary.+pub(super) fn bytes(k: &Kernel, b: &Brep, ascii: bool) -> solidcore::Result<Vec<u8>> {+ let store = AttributeStore::default();+ let records = NotifyRecords::new();+ let env = FromBrepEnv {+ attributes: &store,+ key_of: &key_of,+ records: &records,+ curve_key: &|_: EdgeId| ObjectKey(0),+ uv_curve_key: &|_: EdgeuseId| ObjectKey(0),+ surface_key: &|_: FaceId| ObjectKey(0),+ };+ write_brep_to_file(k, Some(b), &env, ascii)+}++/// `body` written to the file at `path`, ASCII or binary.+pub(crate) fn write(body: &Body, path: &Path, ascii: bool) -> Result<()> {+ let bytes = with_body("smlib_brep_write", body, |k, b| bytes(k, b, ascii))?;+ std::fs::write(path, bytes).map_err(|e| io("writing", path, &e))+}diff --git a/crates/smlib/src/core/history.rs b/crates/smlib/src/core/history.rsnew file mode 100644index 0000000000..e11b73b388--- /dev/null+++ b/crates/smlib/src/core/history.rs@@ -0,0 +1,330 @@+//! Face and edge history on solidcore: a port of the fork's `capi/src/smlib_history.cpp`+//! (`smlib_history_tag`, `smlib_history_read`) onto solidcore's B-rep-owned attribute store+//! ([`Brep::add_attribute`]), which solidcore's operations carry through their edits as SMLib's+//! `SmAObject::Notify` does: Split when a face or edge is cut in two, Merge when two become one,+//! Copy when an object is copied (a boolean copies the second operand into the first), Coincident+//! where a boolean finds one operand's entity lying on the other's. New topology (a boolean's+//! intersection edges) is made without any.+//!+//! The capi's `Tag` is one application attribute ([`Attribute::application`]) per face or edge,+//! with the capi's own handlers ([`AttributeHandlers`]): a split child, a merge's result and the+//! entity a coincidence lands on join the origins in, where SMLib's defaults keep only one; a copy+//! is SMLib's default. The data, the handlers and the reading are the capi's.++use std::collections::{BTreeMap, BTreeSet, HashMap};++use solidcore::geom::attribute::{+ ApplicationValue, Attribute, AttributeHandle, AttributeHandlers, AttributeValue, AttributeView, Behavior, ObjectKey, Placement, ids,+};+use solidcore::kernel::Kernel;+use solidcore::query::api_queries::edge_closest_point;+use solidcore::topology::face::p4 as face4;+use solidcore::topology::{Brep, EdgeId, VertexId, edge};+use solidcore::{EntityRef, Point3, SolidError};+use solidcraft_geom::brep::history::Change;++use super::{Body, answer, with_body};+use crate::history::{Raw, RawEdge, RawFace};+use crate::{Error, Result};+use solidcore::topology::brep::p3::brep_copy;++/// `TAG_ID`: above SMLib's own ids (all below `SM_AI_USER_1`).+const TAG_ID: u64 = ids::USER_1 + 7;++/// Operand numbers and indices a tag accepts (`TAG_MAX`: keeps every value inside 30 bits).+const TAG_MAX: usize = 1 << 30;++/// One (operand, index) pair a face or edge stands for.+type Origin = (usize, usize);++/// The capi's `Tag`: what a face or edge stands for, the operand entities it came from, for a face+/// tagged directly its own boundary edges then (to tell a face that is still whole), and for an+/// edge tagged directly where it lay then (points along it, ends first: to tell an edge that+/// moved). Copy behaviour (`SM_AB_COPY`); a copy (`MakeCopy`) is the same data.+#[derive(Debug, Clone, PartialEq, Default)]+struct Tag {+ origins: BTreeSet<Origin>,+ edges: BTreeSet<i64>,+ at: Vec<Point3>,+}++impl Tag {+ fn attribute(self) -> Attribute {+ Attribute::application(TAG_ID, Behavior::Copy, self)+ }+}++/// `Tag::on`: the tag on `x`, if the attribute of its id there is a [`Tag`].+fn on<'a>(view: &AttributeView<'a>, x: ObjectKey) -> Option<(AttributeHandle, &'a Tag)> {+ let (h, a) = view.find_attribute(x, TAG_ID)?;+ a.application_value::<Tag>().map(|t| (h, t))+}++/// `Tag::join`: adds `o` and `e` to `x`'s tag (its `at` as it was), giving it one with no `at` if+/// it has none (an attribute of the tag's id that is no tag is replaced). Nothing for no `o`.+fn join(view: &AttributeView<'_>, x: ObjectKey, o: &BTreeSet<Origin>, e: &BTreeSet<i64>) -> Vec<Placement> {+ if o.is_empty() {+ return Vec::new();+ }+ if let Some((handle, t)) = on(view, x) {+ let mut t = t.clone();+ t.origins.extend(o.iter().copied());+ t.edges.extend(e.iter().copied());+ return vec![Placement::Edit { handle, value: AttributeValue::Application(ApplicationValue::new(t)) }];+ }+ set(view, x, o.clone(), e.clone(), Vec::new())+}++/// `Tag::set`: replaces whatever tag `x` has (the attribute of the tag's id) with exactly `o`, `e`+/// and `p`.+fn set(view: &AttributeView<'_>, x: ObjectKey, o: BTreeSet<Origin>, e: BTreeSet<i64>, p: Vec<Point3>) -> Vec<Placement> {+ let mut out = Vec::with_capacity(2);+ if let Some((handle, _)) = view.find_attribute(x, TAG_ID) {+ out.push(Placement::Remove { on: x, handle });+ }+ out.push(Placement::Add { on: x, attribute: Tag { origins: o, edges: e, at: p }.attribute() });+ out+}++impl AttributeHandlers for Tag {+ /// A split: both children stand for what the split object stood for, and lie where it lay+ /// (each a piece of it): a child with no tag gets this one's `at` too.+ fn split(&self, view: &AttributeView<'_>, split: ObjectKey, a: ObjectKey, b: ObjectKey) -> solidcore::Result<Vec<Placement>> {+ let mut out = Vec::new();+ for x in [a, b] {+ if x == split {+ continue;+ }+ if on(view, x).is_none() && !self.origins.is_empty() {+ out.extend(set(view, x, self.origins.clone(), self.edges.clone(), self.at.clone()));+ } else {+ out.extend(join(view, x, &self.origins, &self.edges));+ }+ }+ Ok(out)+ }++ /// A merge: the result stands for both (the tags on the sources other than the result).+ fn merge(&self, view: &AttributeView<'_>, a: ObjectKey, b: ObjectKey, result: ObjectKey) -> solidcore::Result<Vec<Placement>> {+ let (mut o, mut e) = (BTreeSet::new(), BTreeSet::new());+ for x in [a, b] {+ if x != result+ && let Some((_, t)) = on(view, x)+ {+ o.extend(t.origins.iter().copied());+ e.extend(t.edges.iter().copied());+ }+ }+ Ok(join(view, result, &o, &e))+ }++ /// One operand's entity found lying on the other's, which survives: it stands for both.+ fn coincident(&self, view: &AttributeView<'_>, _from: ObjectKey, to: ObjectKey) -> solidcore::Result<Vec<Placement>> {+ Ok(join(view, to, &self.origins, &self.edges))+ }+}++/// `read`: what `e`'s tag says (the attribute of the tag's id, if it is a [`Tag`]).+fn tag_on(b: &Brep, e: EntityRef) -> Option<&Tag> {+ let (_, a) = b.entity_attributes(e).into_iter().find(|(_, a)| a.attribute_id() == TAG_ID)?;+ a.application_value::<Tag>()+}++/// `Tag::set` at tagging: replaces whatever tag `e` has with exactly origin `o`, the boundary+/// edges `edges` (a face's) and the points `at` (an edge's).+fn set_on(b: &mut Brep, e: EntityRef, o: Origin, edges: BTreeSet<i64>, at: Vec<Point3>) -> std::result::Result<(), SolidError> {+ let old = b.entity_attributes(e).into_iter().find(|(_, a)| a.attribute_id() == TAG_ID).map(|(h, _)| h);+ if let Some(h) = old {+ b.remove_attribute(e, h)?;+ }+ b.add_attribute(e, Tag { origins: BTreeSet::from([o]), edges, at }.attribute())?;+ Ok(())+}++/// `samples`: points along `e`, its two ends, then three between, evenly in its parameter. Empty+/// where it can't be evaluated.+fn samples(k: &Kernel, b: &Brep, e: EdgeId) -> std::result::Result<Vec<Point3>, SolidError> {+ let edge = b.edge(e)?;+ let Some(curve) = edge.curve.as_ref() else { return Ok(Vec::new()) };+ let (lo, hi) = (edge.interval.min(), edge.interval.max());+ let mut p = Vec::with_capacity(5);+ for t in [0.0, 1.0, 0.25, 0.5, 0.75] {+ let Some(v) = answer(curve.evaluate(k, lo + t * (hi - lo), 0, true, false))? else { return Ok(Vec::new()) };+ let Some(v) = v.first() else { return Ok(Vec::new()) };+ p.push(Point3::new(v.x, v.y, v.z));+ }+ Ok(p)+}++/// `moved`: have `pieces`, the result edges standing for one edge, moved from where its tag says+/// it lay (`at`, the first piece's record of at least two points)? Together they must run between+/// its ends (the vertices only one piece ends on; none for an edge closed on itself, whose end some+/// piece still ends on), and every point it ran through must lie on one of them (within `tol`).+/// One piece is the edge still whole; more, the edge cut by vertices. Pieces with no record of+/// where the edge lay have not moved.+pub(super) fn moved(k: &Kernel, b: &Brep, pieces: &[(EdgeId, &[Point3])], tol: f64) -> std::result::Result<bool, SolidError> {+ let Some(at) = pieces.iter().map(|(_, at)| *at).find(|at| at.len() >= 2) else { return Ok(false) };+ let [a, z, ..] = at else { return Ok(false) };+ let near = |p: &Point3, q: &Point3| p.distance(*q) <= tol;+ let mut ends: BTreeMap<VertexId, usize> = BTreeMap::new();+ for (e, _) in pieces {+ let (Some(s), Some(f)) = edge::start_end_vertices(b, *e)? else { return Ok(true) };+ *ends.entry(s).or_default() += 1;+ *ends.entry(f).or_default() += 1;+ }+ let mut open = Vec::new();+ for (v, n) in &ends {+ if n % 2 == 1 {+ open.push(b.vertex(*v)?.point);+ }+ }+ let span = match open.as_slice() {+ [p, q] => (near(p, a) && near(q, z)) || (near(p, z) && near(q, a)),+ [] => {+ let mut on_end = false;+ for v in ends.keys() {+ on_end = on_end || near(&b.vertex(*v)?.point, a);+ }+ near(a, z) && on_end+ }+ _ => false,+ };+ if !span {+ return Ok(true);+ }+ for q in at.iter().skip(2) {+ // `SmApiEdgeClosestPoint` failing, however it fails, counts as off a piece, as a distance+ // above `tol` does: the face is then Modified, and the operation stands.+ if !pieces.iter().any(|(e, _)| edge_closest_point(k, b, *e, *q).is_ok_and(|c| c.closest.distance <= tol)) {+ return Ok(true);+ }+ }+ Ok(false)+}++/// `smlib_history_tag`: a copy of `body` (`SmApiBrepCopy`) whose face i and edge i stand for face+/// i and edge i of operand `operand` (in its face and edge order, which the copy keeps), a face+/// also recording its boundary edges then, an edge the points it ran through.+pub(crate) fn tag(body: &Body, operand: usize) -> Result<Body> {+ if operand >= TAG_MAX {+ return Err(Error::Argument);+ }+ with_body("smlib_history_tag", body, |k, b| {+ let mut r = brep_copy(k, b)?;+ let faces = r.face_list().to_vec();+ let edges = r.edge_list().to_vec();+ if faces.len() >= TAG_MAX || edges.len() >= TAG_MAX {+ return Ok(Err(Error::Argument));+ }+ let edge_at: HashMap<EdgeId, usize> = edges.iter().enumerate().map(|(i, e)| (*e, i)).collect();+ for (i, f) in faces.iter().enumerate() {+ let own: BTreeSet<i64> =+ face4::edges(&r, *f, None, false, None)?.iter().filter_map(|e| edge_at.get(e).and_then(|j| i64::try_from(*j).ok())).collect();+ set_on(&mut r, EntityRef::Face(*f), (operand, i), own, Vec::new())?;+ }+ for (i, e) in edges.iter().enumerate() {+ let at = samples(k, &r, *e)?;+ set_on(&mut r, EntityRef::Edge(*e), (operand, i), BTreeSet::new(), at)?;+ }+ Ok(Ok(r))+ })?+ .map(Body::new)+}++/// `smlib_history_read`: each face's and edge's origins in `result`, a face's change from how+/// many origins it has, how many result faces share them and whether its boundary is still+/// exactly its origin's edges; each edge's faces. In the body's own face and edge order.+pub(crate) fn read(result: &Body) -> Result<Raw> {+ with_body("smlib_history_read", result, |k, b| {+ let faces = b.face_list().to_vec();+ let edges = b.edge_list().to_vec();+ let face_at: HashMap<_, usize> = faces.iter().enumerate().map(|(i, f)| (*f, i)).collect();+ let edge_at: HashMap<EdgeId, usize> = edges.iter().enumerate().map(|(i, e)| (*e, i)).collect();+ let tol = b.tolerance();++ // Each face's origins and the boundary edges they had; each edge's origins and points.+ let mut fo: Vec<BTreeSet<Origin>> = Vec::with_capacity(faces.len());+ let mut fe: Vec<BTreeSet<usize>> = Vec::with_capacity(faces.len());+ let mut eo: Vec<BTreeSet<Origin>> = Vec::with_capacity(edges.len());+ let mut at: Vec<Vec<Point3>> = Vec::with_capacity(edges.len());+ let mut face_uses: BTreeMap<Origin, usize> = BTreeMap::new();+ let mut edge_uses: BTreeMap<Origin, usize> = BTreeMap::new();+ for f in &faces {+ let (o, e) = tag_on(b, EntityRef::Face(*f)).map(|t| (t.origins.clone(), t.edges.clone())).unwrap_or_default();+ for x in &o {+ *face_uses.entry(*x).or_default() += 1;+ }+ fe.push(e.into_iter().filter_map(|x| usize::try_from(x).ok()).collect());+ fo.push(o);+ }+ for e in &edges {+ let (o, p) = tag_on(b, EntityRef::Edge(*e)).map(|t| (t.origins.clone(), t.at.clone())).unwrap_or_default();+ for x in &o {+ *edge_uses.entry(*x).or_default() += 1;+ }+ at.push(p);+ eo.push(o);+ }++ let mut out_faces = Vec::with_capacity(faces.len());+ for (i, f) in faces.iter().enumerate() {+ let (Some(o), Some(own)) = (fo.get(i), fe.get(i)) else { continue };+ let change = match o.iter().next() {+ None => Change::Generated,+ Some(_) if o.len() > 1 => Change::Merged,+ Some(first) if face_uses.get(first).copied().unwrap_or(0) > 1 => Change::Split,+ Some(first) => {+ // Kept when its boundary is still exactly where the edges it had were: each+ // boundary edge one of its own operand's, standing for one edge only, every+ // piece of that edge on this face (an edge only cut by a vertex, as splitting+ // the face beside it cuts it, is still all there), the pieces where it lay (an+ // edge an operation moved, as a draft moves a tilted face's neighbours' edges,+ // leaves those faces trimmed differently), and those edges exactly the ones it+ // had.+ let mut pieces: BTreeMap<usize, Vec<(EdgeId, &[Point3])>> = BTreeMap::new();+ let mut whole = true;+ for e in face4::edges(b, *f, None, false, None)? {+ let Some(j) = edge_at.get(&e).copied() else {+ whole = false;+ break;+ };+ let (Some(origins), Some(points)) = (eo.get(j), at.get(j)) else {+ whole = false;+ break;+ };+ let only = match origins.iter().next() {+ Some(x) if origins.len() == 1 => *x,+ _ => {+ whole = false;+ break;+ }+ };+ whole = only.0 == first.0;+ if !whole {+ break;+ }+ let p = pieces.entry(only.1).or_default();+ if !p.iter().any(|(x, _)| *x == e) {+ p.push((e, points.as_slice()));+ }+ }+ let mut now = BTreeSet::new();+ for (edge, p) in &pieces {+ whole = whole && p.len() == edge_uses.get(&(first.0, *edge)).copied().unwrap_or(0) && !moved(k, b, p, tol)?;+ now.insert(*edge);+ }+ if whole && now == *own { Change::Kept } else { Change::Modified }+ }+ };+ out_faces.push(RawFace { change, origins: o.iter().copied().collect() });+ }++ let mut out_edges = Vec::with_capacity(edges.len());+ for (i, e) in edges.iter().enumerate() {+ let bounds: BTreeSet<usize> = edge::faces(b, *e, None)?.iter().filter_map(|f| face_at.get(f).copied()).collect();+ let origins = eo.get(i).map(|o| o.iter().copied().collect()).unwrap_or_default();+ out_edges.push(RawEdge { faces: bounds.into_iter().collect(), origins });+ }+ Ok(Raw { faces: out_faces, edges: out_edges })+ })+}diff --git a/crates/smlib/src/core/measure.rs b/crates/smlib/src/core/measure.rsnew file mode 100644index 0000000000..ffeb034d63--- /dev/null+++ b/crates/smlib/src/core/measure.rs@@ -0,0 +1,354 @@+//! The Measure and Check families on solidcore: what `capi/src/smlib_measure.cpp`,+//! `smlib_brep_solid_count` (`smlib_ops.cpp`), `smlib_brep_is_manifold_solid`+//! (`smlib_flat_api.cpp`) and `smlib_brep_check` (`smlib_check.cpp`) do on the C++ kernel, here+//! composed from solidcore's ports of the same SMLib routines.+//!+//! [`check`] fails with "not supported yet" while a test it reaches is unported in solidcore.++use solidcore::error::EntityRef;+use solidcore::geom::assert_array::{AssertArray, AssertReport, obj_type_string};+use solidcore::geom::attribute::{AttributeStore, ObjectKey};+use solidcore::geom::tol::{SmallTopoType, brep_zone_tol_3d, context_xsect_tol_3d};+use solidcore::heal::gap::GapFunction;+use solidcore::intersect::point_class::PointClassType;+use solidcore::mass::integrator::properties::{MassPropertyBehavior, PropertyAttributes, brep_properties, face_properties};+use solidcore::nurbs::b_spline_surface_n_lib::p2::OrientType;+use solidcore::query::api_queries::{brep_bounding_box, brep_is_manifold_solid, brep_material_census, face_bounding_box};+use solidcore::query::brep::BrepClassifier;+use solidcore::topology::brep::p1 as bl;+use solidcore::topology::brep::validation::{CheckLevel as SolidcoreCheckLevel, check_brep};+use solidcore::topology::face::p2::{PPF_AREA, PPF_AREA_FIRST_MOMENTS};+use solidcore::topology::{FaceId, FaceuseId, NamingScheme};+use solidcore::{Kernel, Point3, SolidError, Vec3};++use super::blend::status;+use super::{Body, with_body};+use crate::check::{CheckLevel, CheckReport};+use crate::measure::{MassProperties, PointClass};+use crate::{Error, Result};++const OP: &str = "smlib_measure";++/// The accuracy the C API passes on: finite, clamped to [1e-8, 1e-1].+fn accuracy(relative_accuracy: f64) -> Result<f64> {+ if !relative_accuracy.is_finite() {+ return Err(Error::Argument);+ }+ Ok(relative_accuracy.clamp(1e-8, 1e-1))+}++fn invalid(why: &'static str) -> SolidError {+ SolidError::invalid_input(OP, why)+}++fn finite(v: &[f64]) -> bool {+ v.iter().all(|x| x.is_finite())+}++/// `faces_area` of `smlib_measure.cpp`: every face counted once (SmApiBrepComputeArea, with the+/// [1e-8, 1e-1] envelope instead of its [1e-4, 1e-1]), the total area and, when `first` is set,+/// the area's first moments about `o`. With `only_sheets`, only [`sheet_face`]s (the capi's+/// `counted`).+fn faces_area(k: &Kernel, b: &mut solidcore::Brep, accuracy: f64, o: Point3, first: bool, only_sheets: bool) -> solidcore::Result<(f64, Vec3)> {+ let mut area = 0.0;+ let mut sum = Vec3::new(0.0, 0.0, 0.0);+ let flags = if first { PPF_AREA | PPF_AREA_FIRST_MOMENTS } else { PPF_AREA };+ for f in bl::faces(b, None)? {+ if only_sheets && !sheet_face(b, f)? {+ continue;+ }+ let size = face_bounding_box(k, b, f, false)?.size();+ let edge = size.z.max(size.x.max(size.y));+ let p = face_properties(k, b, f, OrientType::Same, accuracy, o, edge * edge / 100.0, 0.0, flags)?;+ // The area and its moments share one integrand, so a trim boundary integrated the other+ // way round flips both.+ let sign = if p.area < 0.0 { -1.0 } else { 1.0 };+ area += sign * p.area;+ if first {+ sum += p.moments[0] * sign;+ }+ }+ if !area.is_finite() {+ return Err(invalid("non-finite area"));+ }+ Ok((area, sum))+}++/// `sheet_face`: a face with material on neither side, standing free or hung on a solid (a blend+/// sheet stitched between two boxes). `SmBrep::ComputePreciseProperties` takes its area only from+/// faces between a solid region and a void, so such a face is counted on its own.+fn sheet_face(b: &solidcore::Brep, f: FaceId) -> solidcore::Result<bool> {+ let void_side = |u: Option<FaceuseId>| -> solidcore::Result<bool> {+ let Some(u) = u else { return Ok(true) };+ let Some(shell) = b.faceuse(u)?.shell else { return Ok(true) };+ let Some(region) = b.shell(shell)?.region else { return Ok(true) };+ // IsVoid's UNSURE (2) is true in C++: only FALSE is material.+ Ok(b.region(region)?.is_void() != 0)+ };+ let (x, y) = solidcore::topology::face::p2::faceuses(b, f)?;+ Ok(void_side(x)? && void_side(y)?)+}++/// `smlib_brep_mass_properties`: `SmBrep::ComputePreciseProperties` directly, as the C API calls+/// it (not `SmApiBrepComputeMassProperties`: the [1e-8, 1e-1] accuracy envelope, no manifold+/// refusal, the sum over material regions), the face-by-face area and its centroid for a body+/// with no material, and moments about the middle of the box moved to the centroid. A body's area+/// is every face's: the solid's boundary and its sheet faces (fork 9767916).+pub(crate) fn mass_properties(body: &Body, relative_accuracy: f64) -> Result<MassProperties> {+ let accuracy = accuracy(relative_accuracy)?;+ with_body("mass_properties", body, |k, b| {+ let mut material = false;+ for r in bl::regions(b, None)? {+ // IsVoid's UNSURE (2) is true in C++: only FALSE is material.+ material |= b.region(r)?.is_void() == 0;+ }+ // The C API refuses a body with per-entity mass attributes (they would override the unit+ // density). Bodies here carry none: the attribute store passed in is empty.+ let store = AttributeStore::default();+ let attrs = PropertyAttributes { store: &store, key_of: &|_| ObjectKey(0) };+ // Moments about the middle of the box, moved to the centroid below: about the world+ // origin, a body far from it would lose its inertia to cancellation.+ let o = brep_bounding_box(k, b, false)?.mid();+ if !finite(&[o.x, o.y, o.z]) {+ return Err(invalid("non-finite box"));+ }+ if !material {+ let (area, first) = faces_area(k, b, accuracy, o, true, false)?;+ if !(area > 0.0) {+ return Err(invalid("no area"));+ }+ let c = [o.x + first.x / area, o.y + first.y / area, o.z + first.z / area];+ if !finite(&[area, c[0], c[1], c[2]]) {+ return Err(invalid("non-finite result"));+ }+ return Ok(MassProperties { area, volume: 0.0, centroid: c, moments: [0.0; 3], products: [0.0; 3] });+ }+ let p = brep_properties(k, b, accuracy, o, MassPropertyBehavior { density: 1.0, ..MassPropertyBehavior::default() }, &attrs)?;+ let (mass, volume) = (p.mass, p.volume);+ if !mass.is_finite() || !(mass > 0.0) || !(volume > 0.0) {+ return Err(invalid("no mass"));+ }+ // m[4]: first moments about o; m[7]: (y²+z², z²+x², x²+y²) about o; m[6]: (yz, zx, xy)+ // about o. Parallel axes from o to the centroid (unit density: mass = volume).+ let [_, _, _, _, m4, _, m6, m7] = p.moments;+ let d = [m4.x / mass, m4.y / mass, m4.z / mass];+ let (sheets, _) = faces_area(k, b, accuracy, o, false, true)?;+ let r = MassProperties {+ area: p.area + sheets,+ volume,+ centroid: [o.x + d[0], o.y + d[1], o.z + d[2]],+ moments: [+ m7.x - mass * (d[1] * d[1] + d[2] * d[2]),+ m7.y - mass * (d[0] * d[0] + d[2] * d[2]),+ m7.z - mass * (d[0] * d[0] + d[1] * d[1]),+ ],+ products: [m6.x - mass * d[1] * d[2], m6.y - mass * d[2] * d[0], m6.z - mass * d[0] * d[1]],+ };+ if !finite(&[r.area, r.volume]) || !finite(&r.centroid) || !finite(&r.moments) || !finite(&r.products) {+ return Err(invalid("non-finite result"));+ }+ Ok(r)+ })+}++/// `smlib_brep_area`: every face counted once.+pub(crate) fn area(body: &Body, relative_accuracy: f64) -> Result<f64> {+ let accuracy = accuracy(relative_accuracy)?;+ with_body("area", body, |k, b| faces_area(k, b, accuracy, Point3::new(0.0, 0.0, 0.0), false, false).map(|(a, _)| a))+}++/// `smlib_brep_bounds`: `SmBrep::CalculateTightBoundingBox`.+pub(crate) fn bounds(body: &Body) -> Result<([f64; 3], [f64; 3])> {+ with_body("bounds", body, |k, b| {+ let x = brep_bounding_box(k, b, true)?;+ let (lo, hi) = (x.min(), x.max());+ let (lo, hi) = ([lo.x, lo.y, lo.z], [hi.x, hi.y, hi.z]);+ if !finite(&lo) || !finite(&hi) || lo.iter().zip(&hi).any(|(a, b)| a > b) {+ return Err(invalid("no box"));+ }+ Ok((lo, hi))+ })+}++/// `smlib_brep_edge_face_distance`: SMLib's own edge/face gap (`SmEdgeuse::CalcMaxEdgeFaceGap`'s+/// `SmCrvSrfGapFunction` with 20 samples, its largest sample). Indices in the body's edge and+/// face order.+pub(crate) fn edge_face_distance(body: &Body, edge: usize, face: usize) -> Result<f64> {+ let found = with_body("edge_face_distance", body, |k, b| {+ let (Some(&e), Some(&f)) = (bl::edges(b, None)?.get(edge), bl::faces(b, None)?.get(face)) else {+ return Ok(None);+ };+ let interval = b.edge(e)?.interval;+ let (Some(curve), Some(surface)) = (b.edge(e)?.curve.as_ref(), b.face(f)?.surface.as_ref()) else {+ return Err(invalid("edge without curve or face without surface"));+ };+ if !(interval.max() > interval.min()) {+ return Err(invalid("empty edge interval"));+ }+ // SmTol::GetXSectTol3d(brep's context): the process context. The tolerance only+ // classifies the samples; it does not change the distances.+ let tol = context_xsect_tol_3d(k, None, SmallTopoType::NormalSize);+ let mut gaps = GapFunction::crv_srf(tol, curve, &interval, surface, 20);+ let d = gaps.max_gap_sample(k, false)?.length();+ if !d.is_finite() {+ return Err(invalid("non-finite gap"));+ }+ Ok(Some(d))+ })?;+ found.ok_or(Error::Argument)+}++/// `smlib_brep_classify_point`: `SmBrep::Point3DClassify` at the body's own zone tolerance+/// (`SmTol::GetZoneTol3d` of the body), with boundary intersections, so a point within that+/// tolerance of a vertex, an edge or a face is on the boundary and never decided by a ray; else+/// the region it lies in, outside when that region is void (`IsVoid() == TRUE`; `UNSURE` is+/// material, as the capi compares with `TRUE`). Runs on a private copy when a solve needs one+/// (`BrepClassifier`): upstream's `const` method may add UV trim curves to the body.+pub(crate) fn classify_point(body: &Body, p: [f64; 3]) -> Result<PointClass> {+ if !finite(&p) {+ return Err(Error::Argument);+ }+ with_body("classify_point", body, |k, b| {+ let tol = brep_zone_tol_3d(k, b, SmallTopoType::NormalSize);+ let mut classifier = BrepClassifier::of_brep(b);+ let pc = match classifier.point_3d_classify(k, Point3::new(p[0], p[1], p[2]), tol, true) {+ Ok(pc) => pc,+ // Its status, as the capi passes it on (no ray finding a region is SM_ERR).+ Err(e) => return Ok(Err(status(e))),+ };+ Ok(match (pc.point_class(), pc.object()) {+ (PointClassType::Vertex | PointClassType::Edge | PointClassType::Face, _) => Ok(PointClass::OnBoundary),+ (PointClassType::Region, Some(EntityRef::Region(r))) => {+ Ok(if classifier.brep().region(r)?.is_void() == 1 { PointClass::Outside } else { PointClass::Inside })+ }+ // Point3DClassify reports only the four classes above on success: SM_ERR.+ _ => Err(Error::Status(SM_ERR)),+ })+ })?+}++/// `SM_ERR`.+const SM_ERR: i32 = 1001;++/// `smlib_brep_is_manifold_solid`: `SmApiBrepIsManifoldSolid`.+pub(crate) fn is_manifold_solid(body: &Body) -> Result<bool> {+ with_body("is_manifold_solid", body, |_, b| brep_is_manifold_solid(b))+}++/// `smlib_brep_solid_count`: the solids of `SmApiBrepMaterialCensus` (its voids are dropped).+pub(crate) fn solid_count(body: &Body) -> Result<usize> {+ with_body("solid_count", body, |_, b| brep_material_census(b).map(|(solids, _voids)| solids))+}++/// SMLib's `SM_SUCCESS`, the status `SmBrep::ValidatePointers` returns when it finds nothing.+const SM_SUCCESS: i32 = 1000;++/// The capi's `text()`: an empty string reads as `?`.+fn text(s: &str) -> &str {+ if s.is_empty() { "?" } else { s }+}++/// The capi's `line()`: `<reporting type>::Test #<n> <name>: <message> [owner <type>]`, the owner+/// tag only when the report names the owner's type.+fn report_line(r: &AssertReport) -> String {+ let msg = r.format_log_message();+ let mut s = format!("{}::Test #{} {}: {}", text(obj_type_string(r.reporting_type)), r.test_index, text(r.name), text(&msg));+ if let Some(owner) = r.owner_type_string.filter(|o| !o.is_empty()) {+ s.push_str(" [owner ");+ s.push_str(owner);+ s.push(']');+ }+ s+}++/// The capi's `collect()`: appends the failed reports of `list`, one line each, and counts them;+/// SMLib's warnings ([`AssertReport::is_warning`]: `SmBrep` test 21, "Suspicious Shell Count", a+/// body of several faces with one shell each, is one) are neither.+fn collect(list: &AssertArray, out: &mut String, failures: &mut usize) {+ for r in list.reports().iter().filter(|r| !r.ok && !r.is_warning()) {+ *failures += 1;+ out.push_str(&report_line(r));+ out.push('\n');+ }+}++/// Why [`check`] could not run.+enum Refusal {+ /// A test solidcore has not ported (its [`SolidError::Unported`]).+ Unported(&'static str, &'static str),+ /// A body whose geometry owners' identities the check cannot know: a+ /// [`NamingScheme::Unknown`] body.+ Naming(NamingScheme),+}++impl<T> super::dump::Answer for std::result::Result<T, Refusal> {+ fn refusal(&self) -> Option<String> {+ self.is_err().then(|| "the check could not run".to_string())+ }+}++/// `smlib_brep_check` (`smlib_check.cpp`): `SmBrep::ValidatePointers` at `level`, then, when it+/// failed nothing, `SmBrep::AssertValid` at `level` over the whole topology graph, with every+/// failed test as one line of the report and the capi's own lines for a failed status without a+/// report. solidcore's [`check_brep`] runs the same two calls.+///+/// The geometry owners are named as the body's naming scheme names them: `check_brep` reads a+/// [`NamingScheme::Caller`] body's keys from where its maker recorded them (solidcore#1585: an+/// array import through `make_topology_from_data`, `api_brep_copy`); where it recorded none, the+/// arena identities the binders name such an entity by. A [`NamingScheme::Unknown`] body would be+/// checked under arena identities no maker uses: every edge would fail `SmBrep` test 61 on the+/// owner of its curve.+///+/// A test solidcore has not ported yet (its [`SolidError::Unported`]), or a body whose geometry+/// owners' identities the check cannot know, fails the check with "not supported yet": the check+/// never reports a body valid on fewer tests than the C++ kernel runs.+pub(crate) fn check(body: &Body, level: CheckLevel) -> Result<CheckReport> {+ let lv = match level {+ CheckLevel::Basic => SolidcoreCheckLevel::Level0,+ CheckLevel::Geometry => SolidcoreCheckLevel::Level1,+ CheckLevel::All => SolidcoreCheckLevel::Level2,+ };+ let c = match with_body("check", body, |k, b| {+ let naming = b.naming();+ if naming == NamingScheme::Unknown {+ return Ok(Err(Refusal::Naming(naming)));+ }+ match check_brep(k, b, lv) {+ Err(SolidError::Unported { upstream, unit }) => Ok(Err(Refusal::Unported(upstream, unit))),+ r => r.map(Ok),+ }+ })? {+ Ok(c) => c,+ Err(Refusal::Unported(upstream, unit)) => {+ return Err(Error::Solidcore(format!("smlib_brep_check: {upstream}: not supported yet: solidcore has not ported it (unit {unit})")));+ }+ Err(Refusal::Naming(n)) => {+ return Err(Error::Solidcore(format!(+ "smlib_brep_check: not supported yet: the body names its geometry owners by its maker's keys (NamingScheme::{n:?}), which the check cannot know"+ )));+ }+ };+ let mut text = String::new();+ let mut failures = 0usize;+ collect(&c.pointer_reports, &mut text, &mut failures);+ if c.pointers_status != SM_SUCCESS && failures == 0 {+ failures += 1;+ text.push_str(&format!("SmBrep::ValidatePointers failed with status {}\n", c.pointers_status));+ }+ if failures > 0 {+ // The capi does not run AssertValid after a failed pointer check. check_brep runs it when+ // the status failed without a report; that result is dropped here, as the capi never+ // computes it.+ text.push_str("AssertValid skipped: ValidatePointers failed\n");+ } else {+ let Some(ok) = c.assert_valid else {+ return Err(Error::Solidcore("smlib_brep_check: AssertValid did not run after a clean pointer check".into()));+ };+ collect(&c.reports, &mut text, &mut failures);+ if !ok && failures == 0 {+ failures += 1;+ text.push_str("SmBrep::AssertValid failed without a report\n");+ }+ }+ Ok(CheckReport { failures, text })+}diff --git a/crates/smlib/src/core/measure_tests.rs b/crates/smlib/src/core/measure_tests.rsnew file mode 100644index 0000000000..418c02fccd--- /dev/null+++ b/crates/smlib/src/core/measure_tests.rs@@ -0,0 +1,511 @@+//! The Measure and Check families on solidcore's primitives: mass properties, area and bounds+//! against their closed forms ([`crate::measure::closed`]), one solid each, edges on their faces;+//! and (with SMLib built) the same answers as the C++ kernel for the same primitive.++use super::{Body, area, bounds, check, edge_face_distance, is_manifold_solid, make_box, make_cone, make_cylinder, make_sphere, make_torus};+use super::{counts, mass_properties, solid_count};+use crate::check::CheckLevel;+use crate::measure::MEASURE_ACCURACY;+use crate::measure::closed::{self, Closed};++/// The tolerance every quantity meets, relative.+const TOL: f64 = 1e-9;++/// The primitives, as `convert_tests` makes them, with their closed forms.+fn case(name: &str) -> (Body, Closed) {+ let (body, c) = match name {+ "box" => (make_box([1.0, -2.0, 3.0], [10.0, 20.0, 30.0]), closed::cuboid([1.0, -2.0, 3.0], [10.0, 20.0, 30.0])),+ "cylinder" => (make_cylinder([1.0, 2.0, -3.0], 5.0, 12.0), closed::cylinder([1.0, 2.0, -3.0], 5.0, 12.0)),+ "sphere" => (make_sphere([1.0, 2.0, 3.0], 7.0), closed::sphere([1.0, 2.0, 3.0], 7.0)),+ "cone" => (make_cone([0.0, 1.0, 2.0], 6.0, 0.0, 9.0), closed::cone([0.0, 1.0, 2.0], 6.0, 0.0, 9.0)),+ "frustum" => (make_cone([0.0, 1.0, 2.0], 6.0, 2.0, 9.0), closed::cone([0.0, 1.0, 2.0], 6.0, 2.0, 9.0)),+ "torus" => (make_torus([1.0, -1.0, 0.5], 10.0, 3.0), closed::torus([1.0, -1.0, 0.5], 10.0, 3.0)),+ _ => panic!("{name}"),+ };+ (body.unwrap(), c)+}++fn rel(a: f64, b: f64) -> f64 {+ (a - b).abs() / b.abs()+}++/// The body's size: twice its largest radius of gyration, the scale of centroid errors.+fn size(c: &Closed) -> f64 {+ 2.0 * (c.moments.iter().fold(0.0f64, |a, &b| a.max(b)) / c.volume).sqrt()+}++fn mass_properties_match(name: &str) {+ let (b, c) = case(name);+ let m = mass_properties(&b, MEASURE_ACCURACY).unwrap();+ assert!(rel(m.area, c.area) < TOL, "{name}: area {} vs {}", m.area, c.area);+ assert!(rel(m.volume, c.volume) < TOL, "{name}: volume {} vs {}", m.volume, c.volume);+ let imax = c.moments.iter().fold(0.0f64, |a, &b| a.max(b));+ for i in 0..3 {+ assert!((m.centroid[i] - c.centroid[i]).abs() < TOL * size(&c), "{name}: centroid {:?} vs {:?}", m.centroid, c.centroid);+ assert!(rel(m.moments[i], c.moments[i]) < TOL, "{name}: moments {:?} vs {:?}", m.moments, c.moments);+ assert!(m.products[i].abs() < TOL * imax, "{name}: products {:?}", m.products);+ }+}++fn area_matches(name: &str) {+ let (b, c) = case(name);+ let a = area(&b, MEASURE_ACCURACY).unwrap();+ assert!(rel(a, c.area) < TOL, "{name}: area {a} vs {}", c.area);+}++fn bounds_match(name: &str) {+ let (b, c) = case(name);+ let (lo, hi) = bounds(&b).unwrap();+ let s = size(&c);+ for i in 0..3 {+ assert!((lo[i] - c.bounds.0[i]).abs() < TOL * s, "{name}: low {lo:?} vs {:?}", c.bounds.0);+ assert!((hi[i] - c.bounds.1[i]).abs() < TOL * s, "{name}: high {hi:?} vs {:?}", c.bounds.1);+ }+}++fn one_solid(name: &str) {+ let (b, _) = case(name);+ assert_eq!(solid_count(&b).unwrap(), 1, "{name}");+}++fn manifold_solid(name: &str) {+ let (b, _) = case(name);+ assert!(is_manifold_solid(&b).unwrap(), "{name}");+}++/// Every edge lies on the faces it bounds: its distance to the nearest face is 0.+fn edges_lie_on_their_faces(name: &str) {+ let (b, c) = case(name);+ let [faces, edges, _] = counts(&b).unwrap();+ for e in 0..edges {+ let mut d: Vec<f64> = (0..faces).filter_map(|f| edge_face_distance(&b, e, f).ok()).collect();+ d.sort_by(f64::total_cmp);+ assert!(d.first().is_some_and(|&d| d < TOL * size(&c)), "{name}: edge {e}: {d:?}");+ }+ assert!(edge_face_distance(&b, edges, 0).is_err() && edge_face_distance(&b, 0, faces).is_err());+}++fn checks_valid(name: &str) {+ let (b, _) = case(name);+ for level in [CheckLevel::Basic, CheckLevel::Geometry, CheckLevel::All] {+ let r = check(&b, level).unwrap();+ assert!(r.is_valid(), "{name}, {level:?}: {r}");+ }+}++/// Refusing is decided on the body's naming scheme alone. An Unknown body is refused rather than+/// reported invalid on every edge; a Caller one without recorded keys is checked under the arena+/// identities (`check_brep` has no error for it, so no error of its can turn into a refusal).+#[test]+fn check_refuses_only_an_unknown_naming() {+ use solidcore::topology::NamingScheme;+ let name = |naming| {+ let (b, _) = case("box");+ b.0.lock().unwrap().set_naming(naming);+ check(&b, CheckLevel::All)+ };+ let refused = name(NamingScheme::Unknown).unwrap_err().to_string();+ assert!(refused.contains("not supported yet") && refused.contains("NamingScheme::Unknown"), "{refused}");+ name(NamingScheme::Caller).unwrap();+}++/// The C++ kernel's body of the same primitive, built by its C API whichever kernel is in+/// force: a body imported from solidcore's arrays is not the C++ kernel's own (its+/// `edge_face_distance` measures to each face's surface over its domain, which the import sets).+#[cfg(feature = "native")]+fn cpp(name: &str) -> crate::Brep {+ use crate::{Brep, ffi};+ crate::init().unwrap();+ match name {+ "box" => ffi::make_box(&[1.0, -2.0, 3.0], &[10.0, 20.0, 30.0]),+ "cylinder" => ffi::make_cylinder(&[1.0, 2.0, -3.0], 5.0, 12.0),+ "sphere" => ffi::make_sphere(&[1.0, 2.0, 3.0], 7.0),+ "cone" => ffi::make_cone(&[0.0, 1.0, 2.0], 6.0, 0.0, 9.0),+ "frustum" => ffi::make_cone(&[0.0, 1.0, 2.0], 6.0, 2.0, 9.0),+ "torus" => ffi::make_torus(&[1.0, -1.0, 0.5], 10.0, 3.0),+ _ => panic!("{name}"),+ }+ .map(Brep::made)+ .unwrap()+}++/// `x` within `TOL` of the C++ kernel's `y`, relative to `scale`.+#[cfg(feature = "native")]+fn same(x: f64, y: f64, scale: f64, what: &str) {+ assert!((x - y).abs() <= TOL * scale, "{what}: solidcore {x} vs C++ {y}");+}++#[cfg(feature = "native")]+fn mass_properties_parity(name: &str) {+ let (b, c) = case(name);+ let ours = mass_properties(&b, MEASURE_ACCURACY).unwrap();+ let theirs = cpp(name).mass_properties(MEASURE_ACCURACY).unwrap();+ same(ours.area, theirs.area, theirs.area, &format!("{name} area"));+ same(ours.volume, theirs.volume, theirs.volume, &format!("{name} volume"));+ let imax = theirs.moments.iter().fold(0.0f64, |a, &b| a.max(b));+ for i in 0..3 {+ same(ours.centroid[i], theirs.centroid[i], size(&c), &format!("{name} centroid[{i}]"));+ same(ours.moments[i], theirs.moments[i], theirs.moments[i], &format!("{name} moments[{i}]"));+ same(ours.products[i], theirs.products[i], imax, &format!("{name} products[{i}]"));+ }+}++#[cfg(feature = "native")]+fn area_parity(name: &str) {+ let (b, _) = case(name);+ let theirs = cpp(name).area(MEASURE_ACCURACY).unwrap();+ same(area(&b, MEASURE_ACCURACY).unwrap(), theirs, theirs, &format!("{name} area"));+}++#[cfg(feature = "native")]+fn bounds_parity(name: &str) {+ let (b, c) = case(name);+ let (lo, hi) = bounds(&b).unwrap();+ let (tlo, thi) = cpp(name).bounds().unwrap();+ for i in 0..3 {+ same(lo[i], tlo[i], size(&c), &format!("{name} low[{i}]"));+ same(hi[i], thi[i], size(&c), &format!("{name} high[{i}]"));+ }+}++#[cfg(feature = "native")]+fn solid_count_parity(name: &str) {+ let (b, _) = case(name);+ assert_eq!(solid_count(&b).unwrap(), cpp(name).solid_count().unwrap(), "{name}");+}++#[cfg(feature = "native")]+fn manifold_parity(name: &str) {+ let (b, _) = case(name);+ assert_eq!(is_manifold_solid(&b).unwrap(), cpp(name).is_manifold_solid().unwrap(), "{name}");+}++/// The whole edge-by-face distance matrix, the C++ kernel's own (both bodies list their edges+/// and faces in the same order: `convert_tests` shows their arrays are equal).+#[cfg(feature = "native")]+fn distance_parity(name: &str) {+ let (b, c) = case(name);+ let theirs = cpp(name);+ let [faces, edges, _] = counts(&b).unwrap();+ for e in 0..edges {+ for f in 0..faces {+ let (x, y) = (edge_face_distance(&b, e, f), theirs.edge_face_distance(e, f));+ match (x, y) {+ (Ok(x), Ok(y)) => same(x, y, size(&c), &format!("{name} edge {e} face {f}")),+ (x, y) => assert_eq!(x.is_ok(), y.is_ok(), "{name} edge {e} face {f}: {x:?} vs {y:?}"),+ }+ }+ }+}++#[cfg(feature = "native")]+fn check_parity(name: &str) {+ let (b, _) = case(name);+ for level in [CheckLevel::Basic, CheckLevel::Geometry, CheckLevel::All] {+ assert_eq!(check(&b, level).unwrap(), cpp(name).check(level).unwrap(), "{name}, {level:?}");+ }+}++macro_rules! primitive {+ ($m:ident, $name:literal $(, mass: $mass:meta)? $(, area: $area:meta)?) => {+ mod $m {+ use super::*;+ #[test]+ $(#[$mass])?+ fn mass_properties_match_the_closed_forms() {+ mass_properties_match($name);+ }+ #[test]+ $(#[$area])?+ fn area_matches_the_closed_form() {+ area_matches($name);+ }+ #[test]+ fn bounds_match_the_closed_form() {+ bounds_match($name);+ }+ #[test]+ fn is_one_solid() {+ one_solid($name);+ }+ #[test]+ fn is_a_manifold_solid() {+ manifold_solid($name);+ }+ #[test]+ fn edges_lie_on_their_faces() {+ super::edges_lie_on_their_faces($name);+ }+ #[test]+ fn checks_valid() {+ super::checks_valid($name);+ }+ #[cfg(feature = "native")]+ #[test]+ $(#[$mass])?+ fn mass_properties_match_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ mass_properties_parity($name);+ }+ #[cfg(feature = "native")]+ #[test]+ $(#[$area])?+ fn area_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ area_parity($name);+ }+ #[cfg(feature = "native")]+ #[test]+ fn bounds_match_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ bounds_parity($name);+ }+ #[cfg(feature = "native")]+ #[test]+ fn solid_count_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ solid_count_parity($name);+ }+ #[cfg(feature = "native")]+ #[test]+ fn manifold_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ manifold_parity($name);+ }+ #[cfg(feature = "native")]+ #[test]+ fn distances_match_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ distance_parity($name);+ }+ #[cfg(feature = "native")]+ #[test]+ fn check_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ check_parity($name);+ }+ }+ };+}++primitive!(box_, "box");+primitive!(cylinder, "cylinder");+primitive!(sphere, "sphere");+primitive!(cone, "cone");+primitive!(frustum, "frustum");+primitive!(torus, "torus");++/// The head of each report line, `<reporting type>::Test #<n>`, or the whole line for the capi's+/// own lines (a failed status without a report, a skipped AssertValid).+#[cfg(feature = "native")]+fn tests_of(text: &str) -> Vec<&str> {+ text.lines().map(|l| l.find(" #").and_then(|i| l[i + 2..].find(' ').map(|j| &l[..i + 2 + j])).unwrap_or(l)).collect()+}++/// A valid box passes every test at level 2 (SolidCraft's level), with an empty report, on+/// solidcore and on the C++ kernel.+#[test]+fn a_valid_box_passes_level_2() {+ #[cfg(feature = "native")]+ let _cpp = crate::route::on_cpp();+ let (b, _) = case("box");+ let r = check(&b, CheckLevel::All).unwrap();+ assert_eq!((r.failures, r.text.as_str()), (0, ""), "{r}");+ #[cfg(feature = "native")]+ {+ let r = cpp("box").check(CheckLevel::All).unwrap();+ assert_eq!((r.failures, r.text.as_str()), (0, ""), "{r}");+ }+}++/// A box with one corner moved 1 mm off its edges, through the arrays: the check finds it broken,+/// and the C++ kernel fails the same tests on the same arrays.+#[test]+fn a_vertex_off_its_edges_fails_the_check() {+ #[cfg(feature = "native")]+ let _cpp = crate::route::on_cpp();+ use crate::flat::VERTEX_POSITION;+ let (b, _) = case("box");+ let mut a = super::to_arrays(&b).unwrap();+ a.reals.get_mut(&VERTEX_POSITION).unwrap()[0] += 1.0;+ let broken = super::from_arrays(&a).unwrap();+ let r = check(&broken, CheckLevel::All).unwrap();+ assert!(!r.is_valid(), "{r}");+ assert_eq!(r.failures, r.text.lines().filter(|l| l.contains("::Test #")).count(), "{r}");+ #[cfg(feature = "native")]+ {+ let cpp = crate::flat::Flat::from_arrays(&a).unwrap().import().unwrap();+ let c = cpp.check(CheckLevel::All).unwrap();+ assert_eq!(tests_of(&r.text), tests_of(&c.text), "solidcore:\n{}\nC++:\n{}", r.text, c.text);+ assert_eq!(r, c);+ }+}++#[test]+fn hostile_numbers_are_refused() {+ let (b, _) = case("box");+ assert_eq!(mass_properties(&b, f64::NAN).unwrap_err(), crate::Error::Argument);+ assert_eq!(area(&b, f64::INFINITY).unwrap_err(), crate::Error::Argument);+ assert_eq!(edge_face_distance(&b, usize::MAX, 0).unwrap_err(), crate::Error::Argument);+ // Out of range is clamped, not refused.+ assert!(rel(mass_properties(&b, 1e-30).unwrap().volume, 6000.0) < TOL);+ assert!(rel(mass_properties(&b, 10.0).unwrap().volume, 6000.0) < TOL);+}++/// A 20 mm box minus a centred 10 mm box (a sealed void), as solidcore's boolean makes it and as+/// it comes back from arrays listing its solid region's shells inner first.+fn sealed_voids() -> [(&'static str, Body); 2] {+ use crate::BooleanOp;+ use crate::flat::{FACEUSE_FACE, FACEUSE_ORIENTATION, REGION_SHELL_COUNT, SHELL_FACEUSE_COUNT};+ let body = super::boolean::boolean(&make_box([-10.0; 3], [20.0; 3]).unwrap(), &make_box([-5.0; 3], [10.0; 3]).unwrap(), BooleanOp::Subtract)+ .unwrap()+ .unwrap();+ // The bounded solid region of two shells: swap their blocks (the shell counts match, as do+ // the face-use counts, six faces each), so only the face uses move.+ let mut a = super::to_arrays(&body).unwrap();+ let regions = &a.ints[®ION_SHELL_COUNT];+ let first = regions.iter().position(|&n| n == 2).unwrap();+ let shell: usize = regions[..first].iter().map(|&n| usize::try_from(n).unwrap()).sum();+ let counts = &a.ints[&SHELL_FACEUSE_COUNT];+ assert_eq!((counts[shell], counts[shell + 1]), (6, 6));+ let fu: usize = counts[..shell].iter().map(|&n| usize::try_from(n).unwrap()).sum();+ for id in [FACEUSE_FACE, FACEUSE_ORIENTATION] {+ let v = a.ints.get_mut(&id).unwrap();+ let (x, y) = v[fu..fu + 12].split_at_mut(6);+ x.swap_with_slice(y);+ }+ let reordered = super::from_arrays(&a).unwrap();+ [("solidcore's", body), ("inner first", reordered)]+}++/// The sealed void's mass properties: 8000 − 1000 to 1e-9, centroid at the origin, one solid,+/// in either shell order; with SMLib built, the C++ kernel's own.+#[test]+fn a_sealed_void_measures_its_volume() {+ #[cfg(feature = "native")]+ let _cpp = crate::route::on_cpp();+ let want = 8000.0 - 1000.0;+ // Ixx of a cube of side s about its centre: s⁵ / 6.+ let moment = (20.0f64.powi(5) - 10.0f64.powi(5)) / 6.0;+ #[cfg(feature = "native")]+ let theirs = {+ use crate::{Brep, ffi};+ crate::init().unwrap();+ let make = |o: f64, s: f64| ffi::make_box(&[o; 3], &[s; 3]).map(Brep::made).unwrap();+ let (outer, inner) = (make(-10.0, 20.0), make(-5.0, 10.0));+ let h = ffi::ops::boolean(outer.cpp().unwrap(), inner.cpp().unwrap(), ffi::ops::BOOLEAN_SUBTRACT).unwrap();+ ffi::volume(&h, 1e-9).unwrap()+ };+ for (at, b) in sealed_voids() {+ let m = mass_properties(&b, MEASURE_ACCURACY).unwrap();+ assert!(rel(m.volume, want) < TOL, "{at}: volume {}", m.volume);+ assert!(m.centroid.iter().all(|c| c.abs() < TOL * 20.0), "{at}: centroid {:?}", m.centroid);+ assert!(m.moments.iter().all(|&i| rel(i, moment) < TOL), "{at}: moments {:?} vs {moment}", m.moments);+ assert_eq!(solid_count(&b).unwrap(), 1, "{at}");+ #[cfg(feature = "native")]+ same(m.volume, theirs, theirs, &format!("{at} volume"));+ }+}++/// Two 10 mm squares apart in z = 0, one body of two faces with a shell each (as the top and+/// front of a box offset apart across their edge make, kernel case+/// `surfaces/cov-offset-two-faces-across-a-sharp-edge-come-apart`): `SmBrep` test 21,+/// "Suspicious Shell Count", warns of it, and the capi's check counts no warning.+#[test]+fn faces_apart_with_a_shell_each_check_valid() {+ use solidcore::geom::axis2_placement::Axis2Placement;+ use solidcore::geom::vector3d::Vec3;+ use solidcore::primitive::primitive_creation::p1::create_rectangle;++ use super::boolean::boolean2d;+ use super::run;+ use crate::BooleanOp;++ let square = |x: f64| {+ let frame = Axis2Placement::new(Vec3::new(x, 0.0, 0.0), Vec3::new(1.0, 0.0, 0.0), Vec3::new(0.0, 1.0, 0.0));+ run("create_rectangle", |k| create_rectangle(k, 0.0, 10.0, 10.0, &frame)).map(Body::new).unwrap()+ };+ let b = boolean2d(&square(0.0), &square(20.0), BooleanOp::Union).unwrap().unwrap();+ assert_eq!(counts(&b).unwrap()[0], 2);+ for level in [CheckLevel::Basic, CheckLevel::Geometry, CheckLevel::All] {+ let r = check(&b, level).unwrap();+ assert!(r.is_valid(), "{level:?}: {r}");+ }+}++/// `smlib_brep_classify_point` (fork 34d6b2b), the capi test's cases: a 10 x 20 x 30 box at+/// `(1, -2, 3)`: inside, outside, on a face, an edge and a vertex; the cylinder of radius 5 about+/// the z axis through `(1, 2)`: off its curved wall by 1e-8 on it (within the zone tolerance), by+/// 1e-4 inside or outside, on its axis inside, on its top's centre on it. With SMLib built, the+/// C++ kernel's own primitives classify the same.+#[test]+fn points_classify_as_the_capi() {+ #[cfg(feature = "native")]+ let _cpp = crate::route::on_cpp();+ use super::classify_point;+ use crate::measure::PointClass::{Inside, OnBoundary, Outside};++ let (bx, _) = case("box");+ let (cyl, _) = case("cylinder");+ let c45 = std::f64::consts::FRAC_1_SQRT_2;+ let wall = |r: f64| [1.0 + r * c45, 2.0 + r * c45, 3.0];+ let cases = [+ ("box", [6.0, 8.0, 18.0], Inside),+ ("box", [6.0, 8.0, 34.0], Outside),+ ("box", [0.0, -3.0, 2.0], Outside),+ ("box", [6.0, 8.0, 33.0], OnBoundary),+ ("box", [11.0, 8.0, 33.0], OnBoundary),+ ("box", [11.0, 18.0, 33.0], OnBoundary),+ ("box", [1.0, -2.0, 3.0], OnBoundary),+ ("cylinder", wall(5.0 + 1e-8), OnBoundary),+ ("cylinder", wall(5.0 - 1e-8), OnBoundary),+ ("cylinder", wall(5.0 + 1e-4), Outside),+ ("cylinder", wall(5.0 - 1e-4), Inside),+ ("cylinder", [1.0, 2.0, 3.0], Inside),+ ("cylinder", [1.0, 2.0, 9.0], OnBoundary),+ ];+ for (name, p, want) in cases {+ let body = if name == "box" { &bx } else { &cyl };+ assert_eq!(classify_point(body, p).unwrap(), want, "{name} {p:?}");+ #[cfg(feature = "native")]+ {+ use crate::ffi::measure::{POINT_INSIDE, POINT_ON_BOUNDARY, POINT_OUTSIDE, classify_point as cpp_classify};+ let theirs = cpp_classify(cpp(name).cpp().unwrap(), p).unwrap();+ let want_cpp = match want {+ Inside => POINT_INSIDE,+ Outside => POINT_OUTSIDE,+ OnBoundary => POINT_ON_BOUNDARY,+ };+ assert_eq!(theirs, want_cpp, "C++ {name} {p:?}");+ }+ }+ assert_eq!(classify_point(&bx, [f64::NAN, 0.0, 0.0]).unwrap_err(), crate::Error::Argument);+ assert_eq!(classify_point(&bx, [0.0, f64::INFINITY, 0.0]).unwrap_err(), crate::Error::Argument);+}++/// A sheet hung on a solid (fork 9767916's capi test): a 10 mm cube and a 10 x 10 sheet on from its+/// top front edge, merged into one body. Its area is every face's, the cube's 600 and the sheet's+/// 100, not the cube's boundary alone; its volume the cube's. The same on the C++ kernel.+#[test]+fn a_sheet_hung_on_a_solid_counts_in_the_area() {+ #[cfg(feature = "native")]+ let _cpp = crate::route::on_cpp();+ use solidcore::boolean::api_brep::boolean_merge;+ use solidcore::geom::vector3d::Vec3;+ use solidcore::primitive::api_primitives::{create_box, create_plane};+ let both = super::run("cube and flap", |k| {+ let cube = create_box(k, Vec3::new(0.0, 0.0, 0.0), 10.0, 10.0, 10.0)?;+ let flap = create_plane(k, Vec3::new(10.0, 0.0, 10.0), 10.0, 10.0)?;+ boolean_merge(k, cube, flap)+ })+ .map(Body::new)+ .unwrap();+ let m = mass_properties(&both, 1e-8).unwrap();+ assert!((m.area - 700.0).abs() < 1e-6 && (m.volume - 1000.0).abs() < 1e-6, "{m:?}");+ #[cfg(feature = "native")]+ {+ let cpp = crate::Brep::made_core(both);+ let c = crate::ffi::measure::mass_properties(cpp.cpp().unwrap(), 1e-8).unwrap();+ assert!((c[0] - m.area).abs() < 1e-6 && (c[1] - m.volume).abs() < 1e-6, "C++ {c:?} vs {m:?}");+ }+}diff --git a/crates/smlib/src/core/merge.rs b/crates/smlib/src/core/merge.rsnew file mode 100644index 0000000000..0590df93b4--- /dev/null+++ b/crates/smlib/src/core/merge.rs@@ -0,0 +1,178 @@+//! Sewing and merging on solidcore: the C API's `smlib_stitch` (the fork's+//! `capi/src/smlib_sheets.cpp`) and `smlib_merge_faces` (`capi/src/smlib_ops.cpp`, with+//! `capi/src/smlib_pick.h`'s `pick_edges`).+//!+//! As there, each works on a copy of its body (`SmApiBrepCopy`). A stitch is `SmBrep::StitchFaces`+//! at the caller's tolerance, once, then `SmBrep::OrientTrimmedSurfaces`: outward where the faces+//! close into a solid, else only made to agree across their shared edges. `StitchAndOrient` is not+//! used, as the capi does not use it: it caps the tolerance and stitches a second time, so the+//! caller's tolerance would not be the one that decides.+//!+//! `StitchFaces` glues an edge only to an edge one face uses: a sheet laid on edges two faces of+//! a solid already share (a cover over a box's cut top) is left beside the solid. As the fork's+//! e5d9bba, edges still lamina after that pass are glued at the same tolerance to the edges they+//! lie on whatever uses those (`bAllowSpineEdges`), on a copy ([`close_onto_shared_edges`]).++use solidcore::kernel::Kernel;+use solidcore::topology::brep::p1 as bl;+use solidcore::topology::brep::p2::{ArenaNotifyState, is_manifold_solid};+use solidcore::topology::brep::p3::{DeleteFaceOptions, delete_face, orient_trimmed_surfaces, with_kernel_callbacks};+use solidcore::topology::brep::p4::stitch_faces;+use solidcore::topology::brep::p5::remove_topological_edges_and_vertices;+use solidcore::topology::face::p2 as face_p2;+use solidcore::topology::topology_traverser::Marks;+use solidcore::topology::{Brep, FaceId, RegionId, edge};++use super::Body;+use super::blend::{edge_miss, finish, on_copy, pick_edges, points_ok, status, tolerance_ok};+use crate::{Error, Result};+use solidcore::topology::brep::p3::brep_copy;++type Out<T> = std::result::Result<T, Error>;++/// `smlib_stitch`: the faces of a copy of `body` sewn along the vertices and edges that coincide+/// within `tolerance` (finite, positive, at most 1e3), then oriented; with whether the result is a+/// closed solid (no lamina edge left and `IsManifoldSolid`).+pub(crate) fn stitch(body: &Body, tolerance: f64) -> Result<(Body, bool)> {+ if !tolerance.is_finite() || !(tolerance > 0.0) || tolerance > 1e3 {+ return Err(Error::Argument);+ }+ let mut closed = false;+ let r = on_copy("SmBrep::StitchFaces", body, |k, mut b| {+ let mut lamina = match stitch_faces(k, &mut b, tolerance, None, false) {+ Ok(o) => o.lamina_edges,+ Err(e) => return Ok(Err(status(e))),+ };+ if lamina != 0 {+ b = match close_onto_shared_edges(k, b, tolerance, &mut lamina)? {+ Ok(b) => b,+ Err(e) => return Ok(Err(e)),+ };+ }+ let oriented = with_kernel_callbacks(k, &mut b, |k, b, env| {+ let mut marks = Marks::default();+ orient_trimmed_surfaces(k, b, env, &mut marks, true, lamina != 0, None)+ });+ if let Err(e) = oriented {+ return Ok(Err(status(e)));+ }+ b.refresh_cached_topology();+ closed = lamina == 0 && is_manifold_solid(&b)?;+ Ok(Ok(b))+ })?;+ Ok((r, closed))+}++/// How many regions of `b` are material: neither the infinite region nor a void (`IsVoid`'s+/// `UNSURE` counts as void, as the capi's `!IsVoid()`).+fn material_regions(b: &Brep) -> solidcore::Result<usize> {+ let infinite = b.infinite_region();+ let mut n = 0;+ for r in bl::regions(b, None)? {+ n += usize::from(Some(r) != infinite && b.region(r)?.is_void() == 0);+ }+ Ok(n)+}++/// The region on the side of `f`'s faceuse `fu` (its shell's), if any.+fn region_of(b: &Brep, fu: Option<solidcore::topology::FaceuseId>) -> solidcore::Result<Option<RegionId>> {+ let Some(fu) = fu else { return Ok(None) };+ match b.faceuse(fu)?.shell {+ Some(sh) => Ok(b.shell(sh)?.region),+ None => Ok(None),+ }+}++/// `remove_faces_inside`: every face of `b` lying between two material regions is inside the+/// part and removed (`DeleteFace(f, TRUE, TRUE)` with the B-rep open for editing): its regions+/// are joined, and its edges and vertices nothing else uses go with it.+fn remove_faces_inside(k: &mut Kernel, b: &mut Brep) -> solidcore::Result<Out<()>> {+ let infinite = b.infinite_region();+ let mut inside: Vec<FaceId> = Vec::new();+ for f in bl::faces(b, None)? {+ let (u1, u2) = face_p2::faceuses(b, f)?;+ let (Some(r1), Some(r2)) = (region_of(b, u1)?, region_of(b, u2)?) else { continue };+ let material = |r: RegionId| -> solidcore::Result<bool> { Ok(Some(r) != infinite && b.region(r)?.is_void() == 0) };+ if r1 != r2 && material(r1)? && material(r2)? {+ inside.push(f);+ }+ }+ let editing = b.editing_enabled();+ b.set_editing_enabled(true);+ let mut deleted = Ok(());+ {+ let mut state = ArenaNotifyState::new(b);+ let mut env = state.env(None);+ let mut marks = Marks::default();+ for f in inside {+ let options = DeleteFaceOptions { delete_edges_vertices: true, do_region_nesting: true, ..DeleteFaceOptions::default() };+ if let Err(e) = delete_face(k, b, &mut env, &mut marks, f, options) {+ deleted = Err(e);+ break;+ }+ }+ }+ b.set_editing_enabled(editing);+ b.refresh_cached_topology();+ Ok(deleted.map_err(status))+}++/// `close_onto_shared_edges` (fork e5d9bba): `b`, stitched as a manifold with `lamina` edges+/// left free, those glued at `tolerance` to the edges they lie on whatever uses those+/// (`StitchFaces` with `bAllowSpineEdges`) on a copy. The copy is taken, with its count of+/// lamina edges, when the gluing closed a space (a new, material region) and, the faces then+/// between two material regions removed, no edge has more than two faces; a sheet that closes+/// nothing with the solid's faces stays as the manifold stitch left it. A gluing that leaves+/// fewer material regions than it found (a sheet with no sector between the faces at its rim:+/// glued elsewhere it joins the solid's inside to the outside) is refused, as the capi's+/// `SMLIB_ERR_UNSUPPORTED`.+fn close_onto_shared_edges(k: &mut Kernel, b: Brep, tolerance: f64, lamina: &mut u32) -> solidcore::Result<Out<Brep>> {+ let mut c = brep_copy(k, &b)?;+ let material = material_regions(&c)?;+ let outcome = match stitch_faces(k, &mut c, tolerance, None, true) {+ Ok(o) => o,+ Err(e) => return Ok(Err(status(e))),+ };+ if outcome.stitched_edges == 0 {+ return Ok(Ok(b));+ }+ if material_regions(&c)? < material {+ return Ok(Err(Error::Unsupported));+ }+ if let Err(e) = remove_faces_inside(k, &mut c)? {+ return Ok(Err(e));+ }+ for e in bl::edges(&c, None)? {+ if edge::is_spine(&c, e)? {+ return Ok(Ok(b));+ }+ }+ *lamina = outcome.lamina_edges;+ Ok(Ok(c))+}++/// `smlib_merge_faces`: `SmBrep::RemoveTopologicalEdgesAndVertices` on a copy of `body`, keeping+/// the edges nearest `keep` (each within `tolerance`); then `finish` (faces left, and a solid in+/// gives a manifold solid).+pub(crate) fn merge_faces(body: &Body, keep: &[[f64; 3]], tolerance: f64) -> Result<Body> {+ if !points_ok(keep, true) || !tolerance_ok(tolerance) {+ return Err(Error::Argument);+ }+ on_copy("SmBrep::RemoveTopologicalEdgesAndVertices", body, |k, mut b| {+ let kept = if keep.is_empty() {+ Vec::new()+ } else {+ match pick_edges(k, &b, keep, tolerance)? {+ Ok((edges, _)) => edges,+ Err(m) => return Ok(Err(edge_miss(m))),+ }+ };+ let solid_in = is_manifold_solid(&b)?;+ let keep_edges = (!kept.is_empty()).then_some(kept.as_slice());+ if let Err(e) = remove_topological_edges_and_vertices(k, &mut b, keep_edges, None) {+ return Ok(Err(status(e)));+ }+ b.refresh_cached_topology();+ finish(b, solid_in)+ })+}diff --git a/crates/smlib/src/core/merge_tests.rs b/crates/smlib/src/core/merge_tests.rsnew file mode 100644index 0000000000..25f0f8c003--- /dev/null+++ b/crates/smlib/src/core/merge_tests.rs@@ -0,0 +1,457 @@+//! Stitch and merge faces on solidcore, against closed forms: counts, volumes (or areas) and+//! whether the result closes, and every result exports to a record that validates. With SMLib+//! built, the same input converted to the C++ kernel gives the same result or the same error+//! (parity only: the expected values are the analytic ones).+//!+//! A stitch's input is six (or five) separate planar faces of a 10 mm cube, each its own face of+//! one body with its own edges, none shared; a merge's is a cube with four faces cut across, or+//! two boxes unioned, on solidcore.++use std::collections::BTreeMap;++use solidcore::curve::curve::Curve;+use solidcore::curve::line::Line;+use solidcore::geom::extent2d::Extent2d;+use solidcore::geom::vector2d::Vec2;+use solidcore::geom::vector3d::Vec3;+use solidcore::kernel::Kernel;+use solidcore::nurbs::b_spline_curve::p1::KnotType;+use solidcore::nurbs::b_spline_surface::p1::{BSplineSurface, BSplineSurfaceForm, CanonicalSurfaceData};+use solidcore::primitive::api_primitives::{create_box, create_plane};+use solidcore::primitive::api_trim_ops::trim_surface_with_3d_curves;+use solidcore::surface::plane::p1::Plane;+use solidcore::surface::surface::Surface;+use solidcore::topology::Brep;+use solidcore::topology::brep::p2::ArenaNotifyState;+use solidcore::topology::brep::p3::{merge_brep, new_brep};+use solidcore::topology::brep::p8::create_face_from_surface;++use super::merge::{merge_faces, stitch};+use super::sweep::build_faces;+use super::{Body, area, bounds, counts, make_box, run, to_arrays, volume};+use crate::export::native;+use crate::{BooleanOp, Error};++const TOL: f64 = 0.01;++/// The sides of the cube [0, 10]^3 as (origin, u axis, v axis), each over [0, 10]^2.+const SIDES: [([f64; 3], [f64; 3], [f64; 3]); 6] = [+ ([0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]),+ ([0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]),+ ([0.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]),+ ([10.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]),+ ([0.0, 10.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]),+ ([0.0, 0.0, 10.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]),+];++fn v3(p: [f64; 3]) -> Vec3 {+ Vec3::new(p[0], p[1], p[2])+}++/// The sides `sides` of the cube as separate faces of one body, the top lifted by `lift`.+fn loose_faces(sides: &[usize], lift: f64) -> Body {+ run("loose faces", |k| {+ let mut b = new_brep(k, solidcore::geom::tol::USE_DEFAULT, solidcore::geom::tol::USE_DEFAULT)?;+ for &i in sides {+ let Some(&(mut o, u, v)) = SIDES.get(i) else { continue };+ if i == 5 {+ o[2] += lift;+ }+ let plane = Plane::new(v3(o), v3(u), v3(v), Vec2::new(1.0, 1.0), &Extent2d::from_bounds(0.0, 0.0, 10.0, 10.0));+ let domain = Extent2d::from_bounds(0.0, 0.0, 10.0, 10.0);+ build_faces(&mut b, |b, fenv| create_face_from_surface(k, b, Some(Surface::from(plane)), &domain, fenv))?;+ }+ b.refresh_cached_topology();+ Ok(b)+ })+ .map(Body::new)+ .unwrap()+}++/// Two 10 mm cubes side by side along x, unioned: one 20 x 10 x 10 block.+fn two_boxes() -> Body {+ let a = make_box([0.0; 3], [10.0; 3]).unwrap();+ let b = make_box([10.0, 0.0, 0.0], [10.0; 3]).unwrap();+ super::boolean::boolean(&a, &b, BooleanOp::Union).unwrap().unwrap()+}++/// The cube with its four faces across x = 5 cut there (`split_faces`): ten faces.+fn split_cube() -> Body {+ let plane = crate::ssi::Spec::Plane { origin: [5.0, 0.0, 0.0], xaxis: [0.0, 1.0, 0.0], yaxis: [0.0, 0.0, 1.0], u: [-1.0, 11.0], v: [-1.0, 11.0] };+ let cube = make_box([0.0; 3], [10.0; 3]).unwrap();+ super::split::split_faces(&cube, &[0, 1, 2, 3, 4, 5], &[&plane]).unwrap().unwrap().0+}++#[derive(Clone, Copy, Debug)]+enum Input {+ SplitCube,+ /// [`loose_faces`]: which sides, the top's lift.+ Loose(&'static [usize], f64),+ TwoBoxes,+ Box,+}++impl Input {+ fn core(self) -> Body {+ match self {+ Input::Loose(sides, lift) => loose_faces(sides, lift),+ Input::TwoBoxes => two_boxes(),+ Input::SplitCube => split_cube(),+ Input::Box => make_box([0.0; 3], [10.0; 3]).unwrap(),+ }+ }+}++#[derive(Clone, Copy, Debug)]+enum Op {+ Stitch(Input, f64),+ Merge(Input, &'static [[f64; 3]], f64),+}++#[derive(Clone, Debug, PartialEq)]+enum Expect {+ /// A solid: volume, counts, closed.+ Solid(f64, [usize; 3], bool),+ /// A sheet: area, counts, closed.+ Sheet(f64, [usize; 3], bool),+ Fails(Error),+}++const ALL: &[usize] = &[0, 1, 2, 3, 4, 5];+const OPEN: &[usize] = &[0, 1, 2, 3, 4];++fn case(name: &str) -> (Op, Expect) {+ match name {+ "stitch_six_faces_into_a_cube" => (Op::Stitch(Input::Loose(ALL, 0.0), TOL), Expect::Solid(1000.0, [6, 12, 8], true)),+ "stitch_five_faces_into_an_open_box" => (Op::Stitch(Input::Loose(OPEN, 0.0), TOL), Expect::Sheet(500.0, [5, 12, 8], false)),+ // The top 0.05 mm above the walls: farther than the tolerance, so it stays apart.+ "stitch_leaves_a_gap_wider_than_the_tolerance" => (Op::Stitch(Input::Loose(ALL, 0.05), TOL), Expect::Sheet(600.0, [6, 16, 12], false)),+ // Within a 0.1 mm tolerance, the same gap closes.+ // (the top stays on its own plane, so the solid reaches up to it)+ "stitch_closes_a_gap_within_the_tolerance" => (Op::Stitch(Input::Loose(ALL, 0.05), 0.1), Expect::Solid(1005.0, [6, 12, 8], true)),+ "stitch_a_cube_already_sewn" => (Op::Stitch(Input::Box, TOL), Expect::Solid(1000.0, [6, 12, 8], true)),+ "merge_two_boxes_into_one_block" => (Op::Merge(Input::TwoBoxes, &[], TOL), Expect::Solid(2000.0, [6, 12, 8], false)),+ "merge_a_split_cube_into_one" => (Op::Merge(Input::SplitCube, &[], TOL), Expect::Solid(1000.0, [6, 12, 8], false)),+ "merge_a_box_changes_nothing" => (Op::Merge(Input::Box, &[], TOL), Expect::Solid(1000.0, [6, 12, 8], false)),+ "merge_keeps_a_picked_edge" => (Op::Merge(Input::SplitCube, &[[5.0, 5.0, 10.0]], TOL), Expect::Solid(1000.0, [7, 15, 10], false)),+ "merge_picks_near_nothing" => {+ (Op::Merge(Input::SplitCube, &[[5.0, 5.0, 10.0], [50.0, 50.0, 50.0]], TOL), Expect::Fails(Error::NoMatch { point: 1 }))+ }+ _ => panic!("no case {name}"),+ }+}++#[derive(Debug, PartialEq)]+struct Measured {+ size: f64,+ counts: [usize; 3],+ closed: bool,+ bounds: ([f64; 3], [f64; 3]),+ kinds: BTreeMap<String, usize>,+}++type Got = std::result::Result<Measured, Error>;++fn kinds(rec: &solidcraft_geom::brep::Brep) -> BTreeMap<String, usize> {+ let mut out = BTreeMap::new();+ for f in &rec.faces {+ let v = serde_json::to_value(&f.surface).unwrap();+ *out.entry(v["kind"].as_str().unwrap_or("?").to_owned()).or_default() += 1;+ }+ out+}++fn rel(a: f64, b: f64) -> f64 {+ (a - b).abs() / b.abs()+}++fn judge(name: &str, who: &str, got: Got) -> Got {+ let (op, expect) = case(name);+ match (&expect, &got) {+ (Expect::Fails(e), Err(g)) => assert_eq!(g, e, "{name}: {who} failed otherwise"),+ (Expect::Fails(e), Ok(m)) => panic!("{name}: {who} gave {m:?}, expected {e:?}"),+ (_, Err(g)) => panic!("{name}: {who} failed: {g}"),+ (Expect::Solid(s, n, closed) | Expect::Sheet(s, n, closed), Ok(m)) => {+ assert!(rel(m.size, *s) < 1e-9, "{name}: {who} size {} vs analytic {s}", m.size);+ assert_eq!(m.counts, *n, "{name}: {who} counts");+ if matches!(op, Op::Stitch(..)) {+ assert_eq!(m.closed, *closed, "{name}: {who} closed");+ }+ }+ }+ got+}++fn is_sheet(name: &str) -> bool {+ matches!(case(name).1, Expect::Sheet(..))+}++fn solidcore_case(name: &str) -> Got {+ let (op, _) = case(name);+ let r = match op {+ Op::Stitch(input, tol) => stitch(&input.core(), tol),+ Op::Merge(input, keep, tol) => merge_faces(&input.core(), keep, tol).map(|b| (b, false)),+ };+ let got = r.map(|(b, closed)| {+ let (rec, _) = native(&to_arrays(&b).unwrap()).unwrap_or_else(|e| panic!("{name}: record: {e:?}"));+ rec.validate().unwrap_or_else(|e| panic!("{name}: record: {e}"));+ let size = if is_sheet(name) { area(&b, 1e-8) } else { volume(&b, 1e-8) }.unwrap();+ Measured { size, counts: counts(&b).unwrap(), closed, bounds: bounds(&b).unwrap(), kinds: kinds(&rec) }+ });+ judge(name, "solidcore", got)+}++/// The case on the C++ kernel, called directly (whatever the choice), on the input converted+/// from solidcore's.+#[cfg(feature = "native")]+fn cpp_case(name: &str) -> Got {+ use crate::ops::pick_error;+ use crate::{Brep, error, ffi};+ crate::init().unwrap();+ let (op, _) = case(name);+ let r = match op {+ Op::Stitch(input, tol) => ffi::sheets::stitch(Brep::made_core(input.core()).cpp().unwrap(), tol).map_err(error),+ Op::Merge(input, keep, tol) => {+ ffi::ops::merge_faces(Brep::made_core(input.core()).cpp().unwrap(), keep, tol).map(|h| (h, false)).map_err(pick_error)+ }+ };+ let got = r.map(|(h, closed)| {+ let size = if is_sheet(name) { ffi::measure::area(&h, 1e-8) } else { ffi::volume(&h, 1e-8) }.unwrap();+ let n = ffi::counts(&h).unwrap().map(|x| usize::try_from(x).unwrap());+ let bx = ffi::measure::bounds(&h).unwrap();+ let (rec, _) = native(&Brep::made(h).cpp_arrays().unwrap()).unwrap();+ rec.validate().unwrap();+ Measured { size, counts: n, closed, bounds: bx, kinds: kinds(&rec) }+ });+ judge(name, "C++", got)+}++#[cfg(feature = "native")]+fn parity(name: &str) {+ match (solidcore_case(name), cpp_case(name)) {+ (Ok(a), Ok(b)) => {+ assert!(rel(a.size, b.size) < 1e-9, "{name}: solidcore {} vs C++ {}", a.size, b.size);+ assert_eq!(a.counts, b.counts, "{name}: counts (solidcore vs C++)");+ assert_eq!(a.closed, b.closed, "{name}: closed (solidcore vs C++)");+ assert_eq!(a.kinds, b.kinds, "{name}: faces by surface kind (solidcore vs C++)");+ let near = |x: [f64; 3], y: [f64; 3]| x.iter().zip(&y).all(|(p, q)| (p - q).abs() < 1e-6);+ assert!(near(a.bounds.0, b.bounds.0) && near(a.bounds.1, b.bounds.1), "{name}: bounds {:?} vs C++ {:?}", a.bounds, b.bounds);+ }+ (a, b) => assert_eq!(a.err(), b.err(), "{name}: errors (solidcore vs C++)"),+ }+}++macro_rules! cases {+ ($($m:ident $(: $ign:meta)?),* $(,)?) => {$(+ mod $m {+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_closed_form() {+ let _ = super::solidcore_case(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ super::parity(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ fn the_cpp_kernel_matches_the_closed_form() {+ let _cpp = crate::route::on_cpp();+ let _ = super::cpp_case(stringify!($m));+ }+ }+ )*};+}++cases!(+ stitch_six_faces_into_a_cube,+ stitch_five_faces_into_an_open_box,+ stitch_leaves_a_gap_wider_than_the_tolerance,+ stitch_closes_a_gap_within_the_tolerance,+ stitch_a_cube_already_sewn,+ merge_two_boxes_into_one_block,+ merge_a_split_cube_into_one,+ merge_a_box_changes_nothing,+ merge_keeps_a_picked_edge,+ merge_picks_near_nothing,+);++/// The capi's argument checks, before any kernel call.+#[test]+fn hostile_arguments_are_refused() {+ let b = make_box([0.0; 3], [10.0; 3]).unwrap();+ for t in [0.0, -1.0, f64::NAN, f64::INFINITY, 1e3 + 1.0] {+ assert_eq!(stitch(&b, t).err(), Some(Error::Argument), "stitch tolerance {t}");+ }+ for t in [0.0, -1.0, f64::NAN, f64::INFINITY, 1e6] {+ assert_eq!(merge_faces(&b, &[], t).err(), Some(Error::Argument), "merge tolerance {t}");+ }+ assert_eq!(merge_faces(&b, &[[f64::NAN, 0.0, 0.0]], TOL).err(), Some(Error::Argument));+ let many = vec![[0.0; 3]; crate::MAX_POINTS + 1];+ assert_eq!(merge_faces(&b, &many, TOL).err(), Some(Error::Argument));+}++/// A 10 mm cube and, unsewn in the same body (`MergeBrep`), a sheet made on the kernel.+fn cube_and_sheet(sheet: impl FnOnce(&mut Kernel) -> solidcore::Result<Brep>) -> Body {+ run("cube and sheet", |k| {+ let mut cube = create_box(k, Vec3::new(0.0, 0.0, 0.0), 10.0, 10.0, 10.0)?;+ let sheet = sheet(k)?;+ let mut state = ArenaNotifyState::new(&cube);+ let mut env = state.env(None);+ merge_brep(k, &mut env, &mut cube, &sheet, &solidcore::topology::brep::p2::copy_source_ref, None, None, true)?;+ cube.refresh_cached_topology();+ Ok(cube)+ })+ .map(Body::new)+ .unwrap()+}++/// The capi's `cube_and_cover` (capi/tests/sheets.cpp): the cube and a cover over its top, a+/// height field z(x, y) over [0, 10]^2 of `degree` and uniform `spans`, its control points at+/// their Greville abscissae (so its parameters are x and y), z = 10 but for the middle one,+/// 10 + `rise`, trimmed to the square by lines (`SmApiTrimSurfaceWith3dCurves`), so its rim is the+/// cube's top edges.+fn cube_and_cover(degree: usize, spans: usize, rise: f64) -> Body {+ cube_and_sheet(|k| {+ let n = spans + degree;+ let step = 10.0 / spans as f64;+ let unique: Vec<f64> = (0..=spans).map(|k| step * k as f64).collect();+ let mult: Vec<usize> = (0..=spans).map(|k| if k == 0 || k == spans { degree + 1 } else { 1 }).collect();+ let knots: Vec<f64> = unique.iter().zip(&mult).flat_map(|(&u, &m)| std::iter::repeat_n(u, m)).collect();+ let greville: Vec<f64> = (0..n).map(|i| knots[i + 1..=i + degree].iter().sum::<f64>() / degree as f64).collect();+ let mut net = Vec::with_capacity(n * n);+ for i in 0..n {+ for j in 0..n {+ let z = if 2 * i + 1 == n && 2 * j + 1 == n { 10.0 + rise } else { 10.0 };+ net.push(Vec3::new(greville[i], greville[j], z));+ }+ }+ let surface = BSplineSurface::create_canonical(&CanonicalSurfaceData {+ u_degree: degree,+ v_degree: degree,+ control_points: &net,+ form: BSplineSurfaceForm::Unspecified,+ u_multiplicities: &mult,+ v_multiplicities: &mult,+ u_knots: &unique,+ v_knots: &unique,+ knot_type: KnotType::Unspecified,+ weights: None,+ uv_domain: None,+ })?;+ let corner = [[0.0, 0.0], [10.0, 0.0], [10.0, 10.0], [0.0, 10.0]].map(|[x, y]| Vec3::new(x, y, 10.0));+ let mut sides = Vec::with_capacity(4);+ for i in 0..4 {+ sides.push(Curve::from(Line::create_line_segment(3, corner[i], corner[(i + 1) % 4], None)?));+ }+ trim_surface_with_3d_curves(k, Surface::from(surface), &[4], sides)+ })+}++/// A biquadratic Bezier cover rising 9 at its middle control point,+/// z = 10 + 9 * 2s(1-s) * 2t(1-t) (s = x/10, t = y/10): the capi's cover.+fn cube_and_biquadratic_cover() -> Body {+ cube_and_cover(2, 1, 9.0)+}++/// A bicubic cover over 8 spans whose only raised control point is the middle one: the capi's+/// cover lying on the cube's top for 2.5 mm in from every edge.+fn cube_and_bicubic_cover() -> Body {+ cube_and_cover(3, 8, 9.0)+}++/// The capi's flap: a 10 x 10 sheet on from the cube's top edge at x = 10, in the plane z = 10.+fn cube_and_flap() -> Body {+ cube_and_sheet(|k| create_plane(k, Vec3::new(10.0, 0.0, 10.0), 10.0, 10.0))+}++/// The space between the cover and the cube's top encloses 9 * (10/3)^2 = 100 mm^3: sewn, it is+/// part of the solid and the top, now inside it, goes. A closed solid of the cube's five other+/// faces and the cover, 1100 mm^3.+#[test]+fn a_cover_sews_onto_a_cube_into_a_closed_solid() {+ let (sewn, closed) = stitch(&cube_and_biquadratic_cover(), 1e-6).unwrap();+ assert!(closed);+ assert_eq!(counts(&sewn).unwrap()[0], 6);+ let v = volume(&sewn, 1e-8).unwrap();+ assert!((v - 1100.0).abs() < 1e-6, "volume {v}");+}++/// The bicubic cover overlaps the top: no sector between the faces at the rim to sew it into, so+/// it is refused, not sewn so that the cube's inside joins the outside.+#[test]+fn a_cover_lying_on_the_cube_is_refused() {+ assert_eq!(stitch(&cube_and_bicubic_cover(), 1e-6).err(), Some(Error::Unsupported));+}++/// The flap closes nothing with the cube: it stays the sheet beside it the manifold stitch+/// leaves, not glued into an edge three faces would share.+#[test]+fn a_flap_on_a_cube_edge_stays_beside_it() {+ let (sewn, closed) = stitch(&cube_and_flap(), 1e-6).unwrap();+ assert!(!closed);+ assert_eq!(counts(&sewn).unwrap()[0], 7);+ let (v, a) = (volume(&sewn, 1e-8).unwrap(), area(&sewn, 1e-8).unwrap());+ assert!((v - 1000.0).abs() < 1e-6 && (a - 700.0).abs() < 1e-6, "volume {v}, area {a}");+}++/// The same three on C++, the same input converted: the fork's e5d9bba, as its capi tests say.+#[cfg(feature = "native")]+#[test]+fn sheets_on_a_cube_stitch_the_same_on_cpp() {+ let _cpp = crate::route::on_cpp();+ use crate::{Brep, error, ffi};+ crate::init().unwrap();+ let sew = |b: Body| ffi::sheets::stitch(Brep::made_core(b).cpp().unwrap(), 1e-6).map_err(error);+ let (cover, closed) = sew(cube_and_biquadratic_cover()).unwrap();+ assert!(closed);+ assert_eq!(ffi::counts(&cover).unwrap()[0], 6);+ assert!((ffi::volume(&cover, 1e-8).unwrap() - 1100.0).abs() < 1e-6);+ assert_eq!(sew(cube_and_bicubic_cover()).err(), Some(Error::Unsupported));+ let (flap, closed) = sew(cube_and_flap()).unwrap();+ assert!(!closed);+ assert_eq!(ffi::counts(&flap).unwrap()[0], 7);+ assert!((ffi::volume(&flap, 1e-8).unwrap() - 1000.0).abs() < 1e-6);+}++/// The inputs are never changed.+#[test]+fn the_body_stays_as_it_was() {+ let loose = loose_faces(ALL, 0.0);+ let _ = stitch(&loose, TOL).unwrap();+ assert_eq!(counts(&loose).unwrap(), [6, 24, 24]);+ let block = two_boxes();+ let was = counts(&block).unwrap();+ let _ = merge_faces(&block, &[], TOL).unwrap();+ assert_eq!(counts(&block).unwrap(), was);+}++/// Face and edge tags (`Brep::tagged`) through a stitch and a merge on solidcore, as on+/// C++: the input is tagged on solidcore, converted to C++ and tagged the same way there.+#[cfg(feature = "native")]+mod history {+ use crate::{Brep, ffi};++ #[test]+ fn tags_cross_a_stitch() {+ let _cpp = crate::route::on_cpp();+ crate::init().unwrap();+ let a = Brep::made_core(super::loose_faces(super::ALL, 0.0)).tagged(0).unwrap();+ let cpp = Brep::made(ffi::sheets::stitch(a.cpp().unwrap(), super::TOL).unwrap().0).history().unwrap();+ let core = Brep::made_core(super::stitch(a.core().unwrap(), super::TOL).unwrap().0).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ }++ #[test]+ fn tags_cross_a_merge() {+ let _cpp = crate::route::on_cpp();+ crate::init().unwrap();+ let a = Brep::made_core(super::split_cube()).tagged(0).unwrap();+ let cpp = Brep::made(ffi::ops::merge_faces(a.cpp().unwrap(), &[], super::TOL).unwrap()).history().unwrap();+ let core = Brep::made_core(super::merge_faces(a.core().unwrap(), &[], super::TOL).unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ }+}diff --git a/crates/smlib/src/core/offset.rs b/crates/smlib/src/core/offset.rsnew file mode 100644index 0000000000..f07d3bcfa4--- /dev/null+++ b/crates/smlib/src/core/offset.rs@@ -0,0 +1,660 @@+//! Shells, face offsets, thickening, sheet offsets and drafts on solidcore: the C API's logic+//! round SMLib's offset executive, ported from the fork's `capi/src/smlib_ops.cpp`+//! (`smlib_shell`, `smlib_offset_faces`, `smlib_thicken`, `smlib_draft`, `leaves_cavity`,+//! `FaceSet`, `outer_faceuse`, `move_faces`, `draft_faces`), `capi/src/smlib_sheets.cpp`+//! (`smlib_offset_sheet`) and `capi/src/smlib_pick.h` (`pick_faces`).+//!+//! As there, every operation works on a copy of its body (`SmApiBrepCopy`) and picks faces by+//! point; the shell and the offsets are `SmApiShellBrepFull` and `SmApiOffsetBrepFull`, with+//! convex edges extended and the results merged. A sheet offset takes faces that close into a+//! solid as the capi does since tangency-labs/smlib#17.+//!+//! A draft tilts planes and, since tangency-labs/smlib#27, turns a cylinder about the pull into+//! a cone (solidcore's `Cone::lean_cylinder`, solidcore#1545), and since smlib#53 a cone about the+//! pull into the cone its generators turned make. A draft's tilted faces go in through solidcore's+//! `SmBrep::LocalOperation` ([`local_operation`]). The capi's check that it moved some face+//! (`moved_faces`) marks the replacement surfaces; solidcore names a surface by its owning face, so+//! the mark goes on the picked faces, which it stays with through the operation (solidcore#1875).++use solidcore::EntityRef;+use solidcore::SolidError;+use solidcore::geom::attribute::{Attribute, Behavior, ids};+use solidcore::geom::axis2_placement::Axis2Placement;+use solidcore::geom::object::Shape;+use solidcore::geom::vector3d::{Point3, Vec3};+use solidcore::intersect::point_class::PointClassType;+use solidcore::kernel::Kernel;+use solidcore::math::Point2;+use solidcore::nurbs::b_spline_curve::ControlPointForm;+use solidcore::nurbs::b_spline_surface::p1::SurfParamType;+use solidcore::nurbs::b_spline_surface_n_lib::p2::OrientType;+use solidcore::nurbs::knots::Side;+use solidcore::offset::offset_executive::p2::{OffsetOptions, ShellOptions, local_operation_simple, offset_brep_simple, shell_brep_simple};+use solidcore::offset::offset_faces::{OffsetFacesExecutive, OffsetFacesRefusal};+use solidcore::query::api_queries::{face_bounding_box, face_classify_uv, face_closest_point_in_shape, face_internal_point};+use solidcore::query::brep::{BrepIdentity, BrepQuery, LiveBrepObjects};+use solidcore::surface::cone::Cone;+use solidcore::surface::surface::{Surface, SurfaceKind};+use solidcore::topology::brep::{p1 as brep_p1, p2 as brep_p2};+use solidcore::topology::face::p2 as face_p2;+use solidcore::topology::{Brep, BrepId, FaceId, FaceuseId};++use super::blend::{Miss, on_copy, p3, pick, points_ok, status as blend_status, tolerance_ok};+use super::{Body, answer};+use crate::{Error, Result};++/// The capi's statuses as SolidCraft errors: an operation's own result.+type Out<T> = std::result::Result<T, Error>;++/// `SM_ERR_INVALID_INPUT`.+const INVALID_INPUT: i32 = 1007;++/// `SM_ERR_OFFSET_WALLS_TOUCH` (fork a759622), which `status` (smlib_shim.h) reports as+/// `SMLIB_ERR_WALLS_TOUCH`.+const OFFSET_WALLS_TOUCH: i32 = 1042;++/// `status` (smlib_shim.h): an offset whose walls touch is [`Error::WallsTouch`]; a vertex moved+/// past an edge's other end (`SM_ERR_OFFSET_EDGE_VANISHES`, fork 34318f4) is+/// `SMLIB_ERR_UNSUPPORTED`; any other status as the blends pass it on.+fn status(e: SolidError) -> Error {+ match e {+ SolidError::Upstream { code: OFFSET_WALLS_TOUCH, .. } => Error::WallsTouch,+ e if e.is_offset_edge_vanishes() => Error::Unsupported,+ e => blend_status(e),+ }+}++/// `std::fabs(x) > 1e6` and the rest of the capi's size checks: finite, not zero, at most 1e6.+fn distance_ok(x: f64) -> bool {+ x.is_finite() && x != 0.0 && x.abs() <= 1e6+}++/// The B-rep id every shape and face key in this module names the one body by.+const ONE: BrepId = BrepId::from_index(0);++/// Faces with their loose bounding boxes, for nearest-face queries (`FaceSet`).+struct FaceSet {+ faces: Vec<FaceId>,+ boxes: Vec<(Point3, Point3)>,+ /// Each face's shape (`SmApiFaceClosestPoint` makes one per query; it depends only on the+ /// face, so it is made once).+ shapes: Vec<Shape>,+}++impl FaceSet {+ fn new() -> FaceSet {+ FaceSet { faces: Vec::new(), boxes: Vec::new(), shapes: Vec::new() }+ }++ /// `add`: false when the face's box cannot be measured.+ fn add(&mut self, k: &mut Kernel, b: &Brep, f: FaceId) -> solidcore::Result<bool> {+ let Some(bx) = answer(face_bounding_box(k, b, f, false))? else { return Ok(false) };+ let Some(shape) = answer(Shape::new(k, &(ONE, b), &[], &[(ONE, f)], &[], &[]))? else { return Ok(false) };+ self.faces.push(f);+ self.boxes.push((bx.min(), bx.max()));+ self.shapes.push(shape);+ Ok(true)+ }++ /// `nearest`: the distance from `p` to the nearest face, with the nearest point; infinite+ /// when none answers. A face whose box is farther than the nearest face so far is skipped.+ fn nearest(&self, k: &Kernel, live: &LiveBrepObjects<'_, '_>, p: Point3) -> solidcore::Result<(f64, Option<Point3>)> {+ let (mut best, mut at) = (f64::INFINITY, None);+ for ((&f, (lo, hi)), shape) in self.faces.iter().zip(&self.boxes).zip(&self.shapes) {+ let mut bx = 0.0;+ for (l, (h, x)) in [lo.x, lo.y, lo.z].into_iter().zip([hi.x, hi.y, hi.z].into_iter().zip([p.x, p.y, p.z])) {+ let out = (l - x).max((x - h).max(0.0));+ bx += out * out;+ }+ if f64::sqrt(bx) >= best {+ continue;+ }+ if let Some(c) = answer(face_closest_point_in_shape(k, shape, live, (ONE, f), p))?+ && c.distance.is_finite()+ && c.distance < best+ {+ best = c.distance;+ at = Some(c.point);+ }+ }+ Ok((best, at))+ }+}++/// The live view of `b` the closest-point solves read, under `identity`: `query`'s effective+/// identity ([`BrepQuery::effective_identity`]).+fn live<'a, 'i>(b: &'a mut Brep, identity: &'a BrepIdentity<'i>) -> solidcore::Result<LiveBrepObjects<'a, 'i>> {+ LiveBrepObjects::new(b, identity, None)+}++/// `pick_faces` (`face_distance`: `SmApiFaceClosestPoint`; a face whose query returns a status+/// other than success is skipped, [`answer`]).+pub(super) fn pick_faces(k: &mut Kernel, b: &mut Brep, points: &[[f64; 3]], tol: f64) -> solidcore::Result<std::result::Result<Vec<FaceId>, Miss>> {+ let all = brep_p1::faces(b, None)?;+ let model_tol = b.tolerance();+ let mut shapes = Vec::with_capacity(all.len());+ for &f in &all {+ shapes.push(answer(Shape::new(k, &(ONE, &*b), &[], &[(ONE, f)], &[], &[]))?);+ }+ let query = BrepQuery::of_brep(b);+ let identity = query.effective_identity();+ let objects = live(b, &identity)?;+ let k: &Kernel = k;+ let indices: Vec<usize> = (0..all.len()).collect();+ let picked = pick(&indices, points, tol, model_tol, |i, p| {+ let (Some(&f), Some(Some(shape))) = (all.get(i), shapes.get(i)) else { return Ok(None) };+ Ok(answer(face_closest_point_in_shape(k, shape, &objects, (ONE, f), p))?.map(|c| c.distance))+ })?;+ Ok(picked.map(|(p, _)| p.iter().filter_map(|&i| all.get(i).copied()).collect()))+}++/// A face pick's failure as `pick_error` (ops.rs) reads it.+pub(super) fn face_miss(m: Miss) -> Error {+ match m {+ Miss::None(point) => Error::NoMatch { point },+ Miss::Ambiguous(point) => Error::Ambiguous { point },+ }+}++/// `outer_faceuse`: the faceuse of `f` on the outside of its body, the one bounding the infinite+/// region (for a sheet, both do; then the upward one).+fn outer_faceuse(b: &Brep, f: FaceId) -> solidcore::Result<Option<FaceuseId>> {+ let Some(fu) = face_p2::upward_faceuse(b, f)? else { return Ok(None) };+ let use_ = b.faceuse(fu)?;+ let outside = match use_.shell {+ Some(s) => b.shell(s)?.region.is_some() && b.shell(s)?.region == b.infinite_region(),+ None => false,+ };+ Ok(if outside { Some(fu) } else { use_.mate })+}++/// `leaves_cavity`: whether an inward offset of `wall` (> 0) from every face of the solid `b`+/// but `open` leaves a cavity: a point inside `b` farther than `wall`, and a margin, from every+/// face that is offset. A point counts only as the centre of a ball inside `b`, reached from a+/// face sample by stepping inward along the normal, then from ball to ball. The capi refuses a+/// wall this finds no room for before SMLib sees it (C++ SMLib corrupts memory there,+/// solidcore#380); the same refusal here keeps the C++ path's answer.+fn leaves_cavity(k: &mut Kernel, b: &mut Brep, open: &[FaceId], wall: f64) -> solidcore::Result<bool> {+ let list = brep_p1::faces(b, None)?;+ let (mut all, mut walls) = (FaceSet::new(), FaceSet::new());+ for &f in &list {+ if !all.add(k, b, f)? {+ return Ok(false);+ }+ if !open.contains(&f) && !walls.add(k, b, f)? {+ return Ok(false);+ }+ }+ if walls.faces.is_empty() {+ return Ok(true);+ }+ let tol = b.tolerance();+ let margin = (10.0 * tol).max(1e-3 * wall);+ let need = wall + margin;+ // Face samples: a grid over each offset face's domain, the points inside its trims, each+ // with the inward unit normal there.+ const GRID: usize = 5;+ const MAX_SAMPLES: usize = 2048;+ let mut samples: Vec<(Point3, Vec3)> = Vec::new();+ for &f in &walls.faces {+ let Some(fu) = outer_faceuse(b, f)? else { continue };+ let inward = if b.faceuse(fu)?.orientation == OrientType::Same { -1.0 } else { 1.0 };+ let dom = b.face(f)?.uv_domain;+ for i in 0..GRID {+ for j in 0..GRID {+ if samples.len() >= MAX_SAMPLES {+ break;+ }+ let uv: Point2 = dom.evaluate((i as f64 + 0.5) / GRID as f64, (j as f64 + 0.5) / GRID as f64);+ if answer(face_classify_uv(k, b, f, uv))? != Some(PointClassType::Face) {+ continue;+ }+ let Some(surf) = b.face(f)?.surface.as_ref() else { break };+ let (Some(at), Some(n)) = (answer(surf.evaluate_point(k, uv))?, answer(surf.evaluate_normal(k, uv, Side::Left, Side::Left))?) else {+ continue;+ };+ let len = n.length();+ if !(len > 0.0) || !len.is_finite() {+ continue;+ }+ samples.push((at, n * (inward / len)));+ }+ }+ }+ let query = BrepQuery::of_brep(b);+ let identity = query.effective_identity();+ let objects = live(b, &identity)?;+ let k: &Kernel = k;+ // A step of `h` inward from a sample ends at a ball's centre when no face is nearer to it+ // than `h` (the step crossed none, and the ball touches only the sample's face).+ let ball = |s: Point3, n: Vec3, h: f64| -> solidcore::Result<(bool, Point3, f64)> {+ let c = s + n * h;+ let (r, _) = all.nearest(k, &objects, c)?;+ Ok((r.is_finite() && r >= h * (1.0 - 1e-9), c, r))+ };+ // First the direct step of `need` from each sample.+ for &(s, n) in &samples {+ let (inside, c, _) = ball(s, n, need)?;+ if inside && walls.nearest(k, &objects, c)?.0 >= need {+ return Ok(true);+ }+ }+ // Then climbing, from a small ball at each sample: step away from the nearest offset face by+ // most of the ball's radius (staying inside the ball, so inside the body) while the distance+ // from the offset faces grows.+ const STEPS: usize = 48;+ for &(s, n) in &samples {+ let (inside, mut c, mut r) = ball(s, n, margin.max(1e3 * tol))?;+ if !inside {+ continue;+ }+ for _ in 0..STEPS {+ let (d, q) = walls.nearest(k, &objects, c)?;+ if d >= need {+ return Ok(true);+ }+ let Some(q) = q.filter(|_| d > 0.0 && d.is_finite()) else { break };+ let next = c + (c - q) * (0.9 * r / d);+ let (rn, _) = all.nearest(k, &objects, next)?;+ if !(rn > 0.0) || !rn.is_finite() || walls.nearest(k, &objects, next)?.0 <= d * (1.0 + 1e-9) {+ break;+ }+ c = next;+ r = rn;+ }+ }+ Ok(false)+}++/// `SmApiShellBrepFull(b, distance, TRUE, TRUE, TRUE, open, r)`: convex edges extended, results+/// merged, side walls made at a sheet's edges, and (as the fork does, 5448b9a) a thickened+/// sheet's coplanar side walls one face.+fn shell_brep_full(k: &mut Kernel, b: &Brep, distance: f64, open: &[FaceId]) -> solidcore::Result<Brep> {+ let options = ShellOptions {+ offset: OffsetOptions { distance, extend_convex_edges: true, merge_results: true },+ create_offset_solid: true,+ merge_sheet_side_walls: true,+ };+ shell_brep_simple(k, b, options, open)+}++/// `SmApiOffsetBrepFull(b, distance, TRUE, TRUE, r)`.+fn offset_brep_full(k: &mut Kernel, b: &mut Brep, distance: f64) -> solidcore::Result<Brep> {+ offset_brep_simple(k, b, OffsetOptions { distance, extend_convex_edges: true, merge_results: true })+}++/// `finish`: the result must have faces, and a solid input must give a closed manifold solid.+fn finish(b: Brep, solid_in: bool) -> solidcore::Result<Out<Brep>> {+ if b.face_list().is_empty() {+ return Ok(Err(Error::Empty));+ }+ if solid_in && !brep_p2::is_manifold_solid(&b)? {+ return Ok(Err(Error::NotSolid));+ }+ Ok(Ok(b))+}++/// An SMLib call's own status passed on (`status(...)` in the capi), else the value.+fn called<T>(r: solidcore::Result<T>) -> solidcore::Result<Out<T>> {+ match r {+ Ok(v) => Ok(Ok(v)),+ Err(e) => Ok(Err(status(e))),+ }+}++/// `smlib_shell`: the faces nearest `points` (each within `tolerance`) opened, the rest offset+/// by `thickness` (negative: inward) into a wall; none gives a closed hollow body. An inward+/// wall of a solid that leaves no cavity is [`Error::NoRoom`], refused before the shell.+pub(crate) fn shell(body: &Body, points: &[[f64; 3]], tolerance: f64, thickness: f64) -> Result<Body> {+ if !points_ok(points, true) || !tolerance_ok(tolerance) || !distance_ok(thickness) {+ return Err(Error::Argument);+ }+ on_copy("smlib_shell", body, |k, mut w| {+ let picked = match pick_faces(k, &mut w, points, tolerance)? {+ Ok(p) => p,+ Err(m) => return Ok(Err(face_miss(m))),+ };+ let solid_in = brep_p2::is_manifold_solid(&w)?;+ if thickness < 0.0 && solid_in && !leaves_cavity(k, &mut w, &picked, -thickness)? {+ return Ok(Err(Error::NoRoom));+ }+ match called(shell_brep_full(k, &w, thickness, &picked))? {+ Ok(r) => finish(r, solid_in),+ Err(e) => Ok(Err(e)),+ }+ })+}++/// `smlib_offset_faces`: its checks, the pick, the solid check, (moving faces in) the cavity+/// check, then `move_faces`.+pub(crate) fn offset_faces(body: &Body, points: &[[f64; 3]], tolerance: f64, distance: f64) -> Result<Body> {+ if !points_ok(points, false) || !tolerance_ok(tolerance) || !distance_ok(distance) {+ return Err(Error::Argument);+ }+ on_copy("smlib_offset_faces", body, |k, mut w| {+ let picked = match pick_faces(k, &mut w, points, tolerance)? {+ Ok(p) => p,+ Err(m) => return Ok(Err(face_miss(m))),+ };+ if !brep_p2::is_manifold_solid(&w)? {+ return Ok(Err(Error::Argument));+ }+ // Faces moved in so far that no material is left behind them: the body must reach+ // deeper than the move behind the moved faces.+ if distance < 0.0 {+ let others: Vec<FaceId> = brep_p1::faces(&w, None)?.into_iter().filter(|f| !picked.contains(f)).collect();+ if !leaves_cavity(k, &mut w, &others, -distance)? {+ return Ok(Err(Error::NoRoom));+ }+ }+ match move_faces(k, &mut w, &picked, distance) {+ Ok(()) => finish(w, true),+ Err(e) => Ok(Err(e)),+ }+ })+}++/// `move_faces`: moves the picked faces of `b` (in place) `distance` along their outward normals:+/// each gets its surface's offset, and the local operation extends or trims the faces around them+/// to meet it; the tangent blends on them follow (`SmOffsetFacesExecutive`: taken off, the faces+/// moved, put back at their own sizes). A blend that no longer fits is [`Error::NoRoom`], one that+/// cannot be put back as it was [`Error::Unsupported`], one that would need a continuation that+/// cannot be made exactly [`Error::NotExact`], a move that moved nothing [`Error::NoEffect`].+fn move_faces(k: &mut Kernel, b: &mut Brep, picked: &[FaceId], distance: f64) -> Out<()> {+ let mut exec = OffsetFacesExecutive::new();+ exec.offset_faces(k, b, picked, distance).map_err(|e| match exec.refusal() {+ OffsetFacesRefusal::NoRoom => Error::NoRoom,+ OffsetFacesRefusal::Unsupported => Error::Unsupported,+ OffsetFacesRefusal::NotExact => Error::NotExact,+ OffsetFacesRefusal::NoEffect => Error::NoEffect,+ // Not in the fork (solidcore#2020, #2027): the blends cannot be put back, the fillet's+ // status kept. SolidCraft has no such error: a move solidcore does not make.+ OffsetFacesRefusal::NotPutBack => Error::Unsupported,+ OffsetFacesRefusal::None => status(e),+ })+}++/// `smlib_thicken`: a sheet thickened by `thickness` along its normals, or (symmetric) moved back+/// by half first; a closed solid is [`Error::Argument`].+pub(crate) fn thicken(body: &Body, thickness: f64, symmetric: bool) -> Result<Body> {+ if !distance_ok(thickness) {+ return Err(Error::Argument);+ }+ on_copy("smlib_thicken", body, |k, mut w| {+ if brep_p2::is_manifold_solid(&w)? {+ return Ok(Err(Error::Argument));+ }+ if symmetric {+ w = match called(offset_brep_full(k, &mut w, -0.5 * thickness))? {+ Ok(moved) => moved,+ Err(e) => return Ok(Err(e)),+ };+ }+ match called(shell_brep_full(k, &w, thickness, &[]))? {+ Ok(r) => finish(r, true),+ Err(e) => Ok(Err(e)),+ }+ })+}++/// `smlib_offset_sheet`: every face of a sheet moved onto its surface's offset by `distance`+/// along its normal; faces that close into a solid (a sphere's one face, a block's six) give the+/// offset solid (tangency-labs/smlib#17, which dropped the capi's refusal of a closed solid).+pub(crate) fn offset_sheet(body: &Body, distance: f64) -> Result<Body> {+ if !distance_ok(distance) {+ return Err(Error::Argument);+ }+ on_copy("smlib_offset_sheet", body, |k, mut w| {+ // `take`: a result without faces (a sphere moved in to its centre) is SMLIB_ERR_EMPTY.+ match called(offset_brep_full(k, &mut w, distance))? {+ Ok(r) => finish(r, false),+ Err(e) => Ok(Err(e)),+ }+ })+}++/// A unit vector from `v`, as `smlib_draft`'s `unit`; `None` for a vector too short or not+/// finite.+fn unit(v: [f64; 3]) -> Option<Vec3> {+ if !v.iter().all(|x| x.is_finite()) {+ return None;+ }+ let u = p3(v);+ let len = u.length();+ (len > 1e-12 && len.is_finite()).then(|| u * (1.0 / len))+}++/// `outward_normal`: the outward normal of face `f` (its outer faceuse `fu`) at `at`, a point on+/// it: its surface's normal there, turned with the outer faceuse. `None` where SMLib cannot place+/// the point on the surface (the capi's `STEPInversionAnswered` also takes a point outside the+/// domain or off the surface by more than its tolerance; solidcore's inversion answers those with+/// a status, so they are `None` here: the face's own internal point is neither).+fn outward_normal(k: &Kernel, b: &Brep, f: FaceId, fu: FaceuseId, at: Point3) -> solidcore::Result<Option<Vec3>> {+ let Some(surf) = b.face(f)?.surface.as_ref() else { return Ok(None) };+ let Some((step, _)) = answer(surf.step_inversion(k, &surf.step_uv_domain(), at, 1e6, None))? else { return Ok(None) };+ let Some(nurb) = answer(surf.convert_uv_from_step_to_nurbs(k, step))? else { return Ok(None) };+ let Some(mut n) = answer(surf.evaluate_normal(k, nurb, Side::Left, Side::Left))? else { return Ok(None) };+ if b.faceuse(fu)?.orientation != OrientType::Same {+ n = -n;+ }+ Ok(Some(n))+}++/// `drafted_cone` (tangency-labs/smlib#27, #53): the cone a face on the cone or cylinder `cyl` about+/// the pull (its outward normal `n` at `inside`) becomes drafted by `angle` about its circle on the+/// neutral plane (through `origin`, normal `normal`), so that it leans in going along `pull`: its+/// generators turned by `angle` in their planes through the axis, about that circle. With R0 the+/// radius on the neutral plane and t the slope of the radius going along the pull (0 for a+/// cylinder), the radius h along the pull from that circle is R0 + h tan(atan(t) - s angle), s = 1+/// where the face looks away from the axis (a pin), -1 where it looks towards it (a hole). It is+/// the surface's own NURB with each control point moved radially by the new radius over the old at+/// its height, so it keeps the surface's parameters and the face's UV trims stay valid: for a+/// cylinder solidcore's `Cone::lean_cylinder` (solidcore#1545), for a cone the same edit on+/// [`Cone::base_mut`]. [`Error::Unsupported`] when the pull does not run along the axis, the axis+/// lies in the neutral plane, or the cone would close within the face's span.+#[allow(clippy::too_many_arguments)] // the capi's drafted_cone+fn drafted_cone(+ k: &Kernel,+ cyl: &Cone,+ n: Vec3,+ inside: Point3,+ origin: Point3,+ normal: Vec3,+ pull: Vec3,+ angle: f64,+) -> solidcore::Result<Out<Cone>> {+ let frame = cyl.canonical().origin;+ let z = frame.x_axis().cross(frame.y_axis());+ let len = z.length();+ if !(len > 0.0 && len.is_finite()) {+ return Ok(Err(Error::Unsupported));+ }+ let z = z * (1.0 / len);+ let sense = z.dot(pull);+ if (sense.abs() - 1.0).abs() > 1e-9 {+ return Ok(Err(Error::Unsupported));+ }+ let axis = frame.origin();+ let toward = z.dot(normal);+ if toward.abs() < 1e-12 {+ return Ok(Err(Error::Unsupported));+ }+ // The hinge circle's centre: the axis on the neutral plane, at the cone's height v0.+ let v0 = (origin - axis).dot(normal) / toward;+ let centre = axis + z * v0;+ let radial = (inside - centre) - pull * (inside - centre).dot(pull);+ let s = if radial.dot(n) >= 0.0 { 1.0 } else { -1.0 };+ // The cone's radius is linear in its height along z; along the pull it changes by `slope` per+ // unit, and drafted by `turned`.+ let r0 = cyl.radius(v0);+ let slope = (cyl.radius(1.0) - cyl.radius(0.0)) * sense;+ let turned = (slope.atan() - s * angle).tan();+ if !(r0 > 0.0) || !turned.is_finite() {+ return Ok(Err(Error::Unsupported));+ }+ if cyl.is_cylinder() {+ return Ok(answer(cyl.lean_cylinder(k, turned * sense, v0))?.ok_or(Error::Unsupported));+ }+ let mut cone = cyl.clone();+ let net = cone.base_mut();+ let (nu, nv) = (net.number_control_points(SurfParamType::U), net.number_control_points(SurfParamType::V));+ for i in 0..nu {+ for j in 0..nv {+ let Some((p, w)) = answer(net.control_point(ControlPointForm::EuclideanRational, i, j))? else {+ return Ok(Err(Error::Unsupported));+ };+ let h = (p - centre).dot(pull);+ let (was, now) = (cyl.radius(v0 + h * sense), r0 + h * turned);+ if !(was > 0.0 && now > 0.0) {+ return Ok(Err(Error::Unsupported));+ }+ let foot = centre + pull * h;+ if answer(net.set_control_point(ControlPointForm::EuclideanRational, i, j, foot + (p - foot) * (now / was), w))?.is_none() {+ return Ok(Err(Error::Unsupported));+ }+ }+ }+ // `CopyAndAddAnalytics`: the cone's analytic data from its edited NURB.+ if answer(cone.rebuild_step_from_nurb_parameters(k))?.is_none() {+ return Ok(Err(Error::Unsupported));+ }+ Ok(Ok(cone))+}++/// The capi's `Before` mark on what `SmBrep::LocalOperation` is to move: above the history's tag.+const MOVED_MARK: u64 = ids::USER_1 + 8;++/// `Before::mark` on each replacement surface. A surface has no identity apart from its owning+/// face here, and `faces[i]`'s offset face takes `surfaces[i]`, so the mark goes on the picked face+/// and travels as the surface's does (Copy behaviour; solidcore#1875). The one difference, recorded+/// in solidcore's `topology.brep_local_operation--1875-face-mark-for-surface-mark` finding: a merge+/// keeping an unpicked face over a picked one hands that survivor the mark, where SMLib's survivor+/// keeps its own unmarked surface.+pub(super) fn mark_moved(w: &mut Brep, picked: &[FaceId]) -> solidcore::Result<()> {+ for &f in picked {+ w.add_attribute(EntityRef::Face(f), Attribute::long(MOVED_MARK, 0, Behavior::Copy))?;+ }+ Ok(())+}++/// `moved_faces`'s reading (`read_marks`): whether any face of `w` carries the mark, every mark+/// removed.+pub(super) fn moved_faces(w: &mut Brep) -> solidcore::Result<bool> {+ let mut moved = false;+ for f in w.face_list().to_vec() {+ let e = EntityRef::Face(f);+ let marks: Vec<_> = w.entity_attributes(e).into_iter().filter(|(_, a)| a.attribute_id() == MOVED_MARK).map(|(h, _)| h).collect();+ moved = moved || !marks.is_empty();+ for h in marks {+ w.remove_attribute(e, h)?;+ }+ }+ Ok(moved)+}++/// `smlib_draft`: its checks, the solid check, the pick, then `draft_faces`: each picked face (a+/// plane parallel to the pull) gets a copy of its plane turned by `angle` about its line on the+/// neutral plane, and a cylinder about the pull the cone `drafted_cone` gives+/// (tangency-labs/smlib#27); `SmBrep::LocalOperation` extends or trims the faces around them to+/// meet the tilted surfaces.+pub(crate) fn draft(+ body: &Body,+ points: &[[f64; 3]],+ tolerance: f64,+ neutral_origin: [f64; 3],+ neutral_normal: [f64; 3],+ pull: [f64; 3],+ angle: f64,+) -> Result<Body> {+ let (Some(normal), Some(along)) = (unit(neutral_normal), unit(pull)) else { return Err(Error::Argument) };+ if !points_ok(points, false)+ || !tolerance_ok(tolerance)+ || !neutral_origin.iter().all(|x| x.is_finite() && x.abs() <= 1e9)+ || !angle.is_finite()+ || angle == 0.0+ || angle.abs() >= 1.5697963267948966+ {+ return Err(Error::Argument);+ }+ on_copy("smlib_draft", body, |k, mut w| {+ if !brep_p2::is_manifold_solid(&w)? {+ return Ok(Err(Error::Argument));+ }+ let picked = match pick_faces(k, &mut w, points, tolerance)? {+ Ok(p) => p,+ Err(m) => return Ok(Err(face_miss(m))),+ };+ // `draft_faces`.+ let mut surfaces = Vec::with_capacity(picked.len());+ for &f in &picked {+ let fu = outer_faceuse(&w, f)?;+ let face = w.face(f)?;+ let (Some(surf), Some(fu)) = (face.surface.as_ref(), fu) else {+ return Ok(Err(Error::Status(INVALID_INPUT)));+ };+ // A cylinder about the pull drafted becomes a cone (`drafted_cone`).+ if let SurfaceKind::Cone(c) = surf.kind_with_nurb(k)? {+ let cyl = (**c).clone();+ let Some(inside) = answer(face_internal_point(k, &mut w, f))? else {+ return Ok(Err(Error::Status(INVALID_INPUT)));+ };+ let Some(n) = outward_normal(k, &w, f, fu, inside)? else {+ return Ok(Err(Error::Status(INVALID_INPUT)));+ };+ match drafted_cone(k, &cyl, n, inside, p3(neutral_origin), normal, along, angle)? {+ Ok(cone) => surfaces.push(Surface::from(cone)),+ Err(e) => return Ok(Err(e)),+ }+ continue;+ }+ let SurfaceKind::Plane(plane) = surf.kind_with_nurb(k)? else {+ return Ok(Err(Error::Unsupported));+ };+ // The face's outward normal: the plane's, turned with the outer faceuse.+ let mut n = plane.position().z_axis();+ if w.faceuse(fu)?.orientation != OrientType::Same {+ n = -n;+ }+ if n.dot(along).abs() > 1e-6 {+ return Ok(Err(Error::Unsupported));+ }+ let Some(inside) = answer(face_internal_point(k, &mut w, f))? else {+ return Ok(Err(Error::Status(INVALID_INPUT)));+ };+ let toward = along.dot(normal);+ if toward.abs() < 1e-12 {+ return Ok(Err(Error::Argument));+ }+ let hinge = inside + along * ((p3(neutral_origin) - inside).dot(normal) / toward);+ // Turning n about n x pull by `angle` gives n cos(angle) + pull sin(angle).+ let axis = n.cross(along);+ let len = axis.length();+ if !(len > 0.5) {+ return Ok(Err(Error::Unsupported));+ }+ let axis = axis * (1.0 / len);+ let Some(surf) = w.face(f)?.surface.as_ref() else {+ return Ok(Err(Error::Status(INVALID_INPUT)));+ };+ let Some(mut tilted) = answer(surf.copy(k))? else {+ return Ok(Err(Error::Status(INVALID_INPUT)));+ };+ let mut turn = Axis2Placement::IDENTITY;+ turn.rotate_about_axis_at_point(angle, hinge, axis);+ if answer(tilted.transform(k, &turn, None))?.is_none() {+ return Ok(Err(Error::Status(INVALID_INPUT)));+ }+ surfaces.push(tilted);+ }+ // `moved_faces(b, status(b->LocalOperation(faces, surfaces)))`, its marks on the picked+ // faces (`mark_moved`).+ mark_moved(&mut w, &picked)?;+ if let Err(e) = called(local_operation_simple(k, &mut w, &picked, surfaces))? {+ return Ok(Err(e));+ }+ if !moved_faces(&mut w)? {+ return Ok(Err(Error::NoEffect));+ }+ finish(w, true)+ })+}diff --git a/crates/smlib/src/core/offset_tests.rs b/crates/smlib/src/core/offset_tests.rsnew file mode 100644index 0000000000..6241ed1094--- /dev/null+++ b/crates/smlib/src/core/offset_tests.rs@@ -0,0 +1,909 @@+//! Shells, face offsets, thickening, sheet offsets and drafts on solidcore, against closed forms:+//! every result exports to a record that validates. With SMLib built, the same case on the C+++//! kernel gives the same volume (or, for a sheet, area), counts and faces by surface kind, or the+//! same error (parity only: the expected values are the analytic ones).+//!+//! The bodies are solidcore's own boxes, cylinders and linear sweeps (and booleans of them).++use std::collections::BTreeMap;+use std::f64::consts::PI;+use std::sync::mpsc;+use std::time::Duration;++use solidcore::curve::curve::Curve;+use solidcore::curve::ellipse::Ellipse;+use solidcore::geom::axis2_placement::Axis2Placement;+use solidcore::geom::extent1d::Extent1d;+use solidcore::geom::vector3d::Vec3;+use solidcore::primitive::api_curves::create_line_segment;+use solidcore::sweep::api_brep::create_linear_sweep;++use super::offset::{draft, mark_moved, moved_faces, offset_faces, offset_sheet, shell, thicken};+use super::{Body, area, bounds, counts, make_box, make_cylinder, make_sphere, run, to_arrays, volume};+use crate::export::native;+use crate::{BooleanOp, Error};++/// A case longer than this is a hang.+const TIMEOUT: Duration = Duration::from_secs(300);++/// How near a pick point must be.+const TOL: f64 = 0.01;++#[derive(Clone, Copy, Debug)]+enum Shape {+ Box([f64; 3], [f64; 3]),+ Cylinder([f64; 3], f64, f64),+ Sphere([f64; 3], f64),+ /// A frustum about +Z: base centre, base radius, top radius, height.+ Frustum([f64; 3], f64, f64, f64),+ /// A sheet: the line from the first point to the second swept along `dir` by `dist`.+ LineSheet([f64; 3], [f64; 3], [f64; 3], f64),+ /// A sheet: the arc about +Z through `center` of `radius` from 0 to `degrees`, swept along+ /// +Z by `height`.+ ArcSheet([f64; 3], f64, f64, f64),+ /// Rig case shell/4711: a 60 x 40 x 10 block less an r3 through hole at (22.5, 7) and a+ /// 10 x 10 notch on the front edge from x = 25 to 35.+ Notched,+}++fn v3(p: [f64; 3]) -> Vec3 {+ Vec3::new(p[0], p[1], p[2])+}++impl Shape {+ fn core(self) -> Body {+ match self {+ Shape::Box(o, s) => make_box(o, s).unwrap(),+ Shape::Cylinder(o, r, h) => make_cylinder(o, r, h).unwrap(),+ Shape::Sphere(o, r) => make_sphere(o, r).unwrap(),+ Shape::Frustum(o, a, b, h) => super::make_cone(o, a, b, h).unwrap(),+ Shape::LineSheet(a, b, dir, dist) => run("sheet", |k| {+ let c = Curve::from(create_line_segment(v3(a), v3(b))?);+ create_linear_sweep(k, &[Some(&c)], v3(dir), dist, false)+ })+ .map(Body::new)+ .unwrap(),+ Shape::ArcSheet(o, r, degrees, h) => run("sheet", |k| {+ let frame = Axis2Placement::new(v3(o), Vec3::new(1.0, 0.0, 0.0), Vec3::new(0.0, 1.0, 0.0));+ let c = Curve::from(Ellipse::create_canonical_circle(k, &frame, r, Some(&Extent1d::from_min_max(0.0, degrees)), None)?);+ create_linear_sweep(k, &[Some(&c)], Vec3::new(0.0, 0.0, 1.0), h, false)+ })+ .map(Body::new)+ .unwrap(),+ Shape::Notched => {+ let block = make_box([0.0; 3], [60.0, 40.0, 10.0]).unwrap();+ let pin = make_cylinder([22.5, 7.0, -5.0], 3.0, 20.0).unwrap();+ let notch = make_box([25.0, -5.0, -5.0], [10.0, 10.0, 20.0]).unwrap();+ let a = super::boolean::boolean(&block, &pin, BooleanOp::Subtract).unwrap().unwrap();+ super::boolean::boolean(&a, ¬ch, BooleanOp::Subtract).unwrap().unwrap()+ }+ }+ }+}++#[derive(Clone, Debug)]+enum Op {+ /// `Brep::shell`: open faces, thickness.+ Shell(Shape, Vec<[f64; 3]>, f64),+ /// `Brep::offset_faces`: faces, distance.+ OffsetFaces(Shape, Vec<[f64; 3]>, f64),+ /// `Brep::thicken`: thickness, symmetric.+ Thicken(Shape, f64, bool),+ /// `Brep::offset_sheet`: distance.+ OffsetSheet(Shape, f64),+ /// `Brep::draft`: faces, neutral origin, neutral normal, pull, angle.+ Draft(Shape, Vec<[f64; 3]>, [f64; 3], [f64; 3], [f64; 3], f64),+}++/// What a case must give.+#[derive(Clone, Debug)]+enum Expect {+ /// A solid of this volume (relative 1e-9).+ Volume(f64),+ /// A solid of this volume whose bounds along z are these.+ Slab(f64, f64, f64),+ /// A solid of this volume (relative 1e-9) whose bounds are these.+ Solid(f64, [f64; 3], [f64; 3]),+ /// A sheet of this area (relative 1e-9) whose bounds are these.+ Sheet(f64, [f64; 3], [f64; 3]),+ /// This error.+ Fails(Error),+}++struct Case {+ op: Op,+ expect: Expect,+}++/// A 30 x 20 x 10 block from the origin.+const BLOCK: Shape = Shape::Box([0.0; 3], [30.0, 20.0, 10.0]);+const ABC: f64 = 6000.0;+/// A point on its top face.+const TOP: [f64; 3] = [15.0, 10.0, 10.0];+/// A point on its front face (y = 0).+const FRONT: [f64; 3] = [15.0, 0.0, 5.0];+/// The z axis: a neutral plane's normal and a pull.+const Z: [f64; 3] = [0.0, 0.0, 1.0];+/// A 30 x 20 sheet in z = 0: the x axis from 0 to 30 swept 20 along y.+const PLATE: Shape = Shape::LineSheet([0.0; 3], [30.0, 0.0, 0.0], [0.0, 1.0, 0.0], 20.0);+/// A sphere of radius 10 about the origin.+const BALL: Shape = Shape::Sphere([0.0; 3], 10.0);+/// A quarter of a cylinder of radius 5 about the z axis, 10 high.+const QUARTER: Shape = Shape::ArcSheet([0.0; 3], 5.0, 90.0, 10.0);++fn case(name: &str) -> Case {+ let c = |op, expect| Case { op, expect };+ match name {+ // abc - (a - 2t)(b - 2t)(c - t), t = 2.+ "shell_box_open_top" => c(Op::Shell(BLOCK, vec![TOP], -2.0), Expect::Volume(ABC - 26.0 * 16.0 * 8.0)),+ // A void: abc - (a - 2t)(b - 2t)(c - 2t).+ "shell_box_closed" => c(Op::Shell(BLOCK, vec![], -2.0), Expect::Volume(ABC - 26.0 * 16.0 * 6.0)),+ // Closed and outward, the convex edges extended: (a + 2t)(b + 2t)(c + 2t) - abc, t = 1.+ "shell_box_closed_outward" => c(Op::Shell(BLOCK, vec![], 1.0), Expect::Volume(32.0 * 22.0 * 12.0 - ABC)),+ // Outward, the convex edges extended: (a + 2t)(b + 2t)(c + t) - abc, t = 1.+ "shell_box_outward" => c(Op::Shell(BLOCK, vec![TOP], 1.0), Expect::Volume(32.0 * 22.0 * 11.0 - ABC)),+ // r = 5, h = 10, open at the top, t = 1: π r² h - π (r - t)² (h - t).+ "shell_cylinder_open_top" => {+ c(Op::Shell(Shape::Cylinder([0.0; 3], 5.0, 10.0), vec![[0.0, 2.0, 10.0]], -1.0), Expect::Volume(PI * 25.0 * 10.0 - PI * 16.0 * 9.0))+ }+ // A wall of 15 inside a block 20 wide leaves no cavity.+ "shell_too_thick" => c(Op::Shell(BLOCK, vec![TOP], -15.0), Expect::Fails(Error::NoRoom)),+ // The hole's offset (r 3 + 2) is tangent to the front's (y = 2): the walls meet along a+ // line, which bounds no solid.+ "shell_walls_touch" => c(Op::Shell(Shape::Notched, vec![[50.0, 30.0, 0.0]], -2.0), Expect::Fails(Error::WallsTouch)),+ "shell_pick_near_nothing" => c(Op::Shell(BLOCK, vec![TOP, [100.0; 3]], -2.0), Expect::Fails(Error::NoMatch { point: 1 })),+ // The top front edge's midpoint is as near the top as the front.+ "shell_pick_ambiguous" => c(Op::Shell(BLOCK, vec![[15.0, 0.0, 10.0]], -2.0), Expect::Fails(Error::Ambiguous { point: 0 })),+ // A plate of 30 x 20 thickened 2: 1200, 2 thick along z; symmetric, from -1 to 1.+ "thicken_plate" => c(Op::Thicken(PLATE, 2.0, false), Expect::Slab(1200.0, 0.0, 2.0)),+ "thicken_plate_symmetric" => c(Op::Thicken(PLATE, 2.0, true), Expect::Slab(1200.0, -1.0, 1.0)),+ "thicken_a_solid" => c(Op::Thicken(BLOCK, 2.0, false), Expect::Fails(Error::Argument)),+ // The plate moved 3 along its normal (+z: the x axis swept along y): still 600, at z = 3.+ "offset_sheet_plate" => c(Op::OffsetSheet(PLATE, 3.0), Expect::Sheet(600.0, [0.0, 0.0, 3.0], [30.0, 20.0, 3.0])),+ // A sphere's one face closes on itself (tangency-labs/smlib fix #17): r = 10 moved out 2 is+ // the ball of radius 12, (4/3) π 12³; moved in 10, to its centre, nothing is left.+ "offset_sheet_a_sphere" => c(Op::OffsetSheet(BALL, 2.0), Expect::Volume(4.0 / 3.0 * PI * 12.0f64.powi(3))),+ "offset_sheet_a_sphere_to_its_centre" => c(Op::OffsetSheet(BALL, -10.0), Expect::Fails(Error::Empty)),+ // The quarter cylinder moved 2 along its normal (outward: the arc's tangent swept along+ // z): radius 7, area (π/2) 7 · 10.+ "offset_sheet_quarter_cylinder" => c(Op::OffsetSheet(QUARTER, 2.0), Expect::Sheet(PI / 2.0 * 7.0 * 10.0, [0.0, 0.0, 0.0], [7.0, 7.0, 10.0])),+ // A closed sheet offsets as an open one (tangency-labs/smlib fix #17, develop 9d0fb564):+ // each face moved out 1 along its normal, the convex edges extended, gives the block+ // (a + 2d)(b + 2d)(c + 2d) of six planes, from -d to (a, b, c) + d.+ "offset_sheet_a_solid" => c(Op::OffsetSheet(BLOCK, 1.0), Expect::Solid(32.0 * 22.0 * 12.0, [-1.0, -1.0, -1.0], [31.0, 21.0, 11.0])),+ // The top moved out 2: abc + d·ab.+ "offset_faces_top_out" => c(Op::OffsetFaces(BLOCK, vec![TOP], 2.0), Expect::Volume(ABC + 2.0 * 600.0)),+ // The top moved in 10, as deep as the block: nothing left behind it.+ "offset_faces_through" => c(Op::OffsetFaces(BLOCK, vec![TOP], -10.0), Expect::Fails(Error::NoRoom)),+ // The four sides drafted θ = 5° about the bottom (z = 0), pulled along +z, leaning in:+ // the section at height z is (a - 2 z tanθ)(b - 2 z tanθ), so+ // V = abh - (a + b) h² tanθ + (4/3) h³ tan²θ.+ "draft_box_sides" => {+ let s = (5.0f64).to_radians().tan();+ let (a, b, h) = (30.0, 20.0, 10.0);+ let sides = vec![[15.0, 0.0, 5.0], [30.0, 10.0, 5.0], [15.0, 20.0, 5.0], [0.0, 10.0, 5.0]];+ c(+ Op::Draft(BLOCK, sides, [0.0; 3], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0], 5f64.to_radians()),+ Expect::Volume(a * b * h - (a + b) * h * h * s + 4.0 / 3.0 * h * h * h * s * s),+ )+ }+ // The front (y = 0) alone drafted θ = 5° about the bottom: a wedge of a h² tanθ / 2+ // comes off along its length.+ "draft_one_side" => {+ let s = (5.0f64).to_radians().tan();+ c(Op::Draft(BLOCK, vec![FRONT], [0.0; 3], Z, Z, 5f64.to_radians()), Expect::Volume(ABC - 30.0 * 100.0 * s / 2.0))+ }+ // A negative angle leans it out: the same wedge goes on.+ "draft_one_side_out" => {+ let s = (5.0f64).to_radians().tan();+ c(Op::Draft(BLOCK, vec![FRONT], [0.0; 3], Z, Z, -5f64.to_radians()), Expect::Volume(ABC + 30.0 * 100.0 * s / 2.0))+ }+ // Hinged at the top (z = 10) and leaning in going up, the face leans out below the+ // hinge: the wedge goes on.+ "draft_one_side_hinged_at_the_top" => {+ let s = (5.0f64).to_radians().tan();+ c(Op::Draft(BLOCK, vec![FRONT], [0.0, 0.0, 10.0], Z, Z, 5f64.to_radians()), Expect::Volume(ABC + 30.0 * 100.0 * s / 2.0))+ }+ // A cylinder along the pull drafts to a cone (tangency-labs/smlib fix #27, develop+ // 9d0fb564): R = 5, h = 10, θ = 0.1 about the bottom, leaning in: a frustum of radii R+ // and r = R - h tanθ (a cone and its two caps): V = π h (R² + R r + r²) / 3.+ "draft_a_curved_face" => {+ let (big, h) = (5.0, 10.0);+ let small = big - h * 0.1f64.tan();+ c(+ Op::Draft(Shape::Cylinder([0.0; 3], big, h), vec![[5.0, 0.0, 5.0]], [0.0; 3], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0], 0.1),+ Expect::Volume(PI * h * (big * big + big * small + small * small) / 3.0),+ )+ }+ // A cone r 10 at its base to 8 at its top, 20 tall, drafted 5° about its base turns its+ // generators 5° more (fork d51a723): r 10 + 20 tan(atan(-0.1) - 5°) at the top.+ "draft_a_cone_about_the_pull" => {+ let (big, h, a) = (10.0, 20.0, 5f64.to_radians());+ let small = big + h * ((-0.1f64).atan() - a).tan();+ c(+ Op::Draft(Shape::Frustum([0.0; 3], big, 8.0, h), vec![[0.0, 9.0, 10.0]], [0.0; 3], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0], a),+ Expect::Volume(PI * h * (big * big + big * small + small * small) / 3.0),+ )+ }+ // The top is square to the pull, not along it.+ "draft_a_face_across_the_pull" => {+ c(Op::Draft(BLOCK, vec![TOP], [0.0; 3], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0], 0.1), Expect::Fails(Error::Unsupported))+ }+ _ => panic!("{name}"),+ }+}++/// The tolerance a case picks with: the ambiguous point lies on its two faces.+fn tolerance(name: &str) -> f64 {+ if name == "shell_pick_ambiguous" { 1.0 } else { TOL }+}++fn rel(a: f64, b: f64) -> f64 {+ (a - b).abs() / b.abs()+}++#[derive(Debug, PartialEq)]+struct Measured {+ /// The volume of a solid, the area of a sheet.+ size: f64,+ bounds: ([f64; 3], [f64; 3]),+ counts: [usize; 3],+ kinds: BTreeMap<String, usize>,+}++fn kinds(rec: &solidcraft_geom::brep::Brep) -> BTreeMap<String, usize> {+ let mut out = BTreeMap::new();+ for f in &rec.faces {+ let v = serde_json::to_value(&f.surface).unwrap();+ *out.entry(v["kind"].as_str().unwrap_or("?").to_owned()).or_default() += 1;+ }+ out+}++fn is_sheet(e: &Expect) -> bool {+ matches!(e, Expect::Sheet(..))+}++fn on_core(name: &str, c: &Case) -> crate::Result<Body> {+ let tol = tolerance(name);+ match &c.op {+ Op::Shell(s, points, t) => shell(&s.core(), points, tol, *t),+ Op::OffsetFaces(s, points, d) => offset_faces(&s.core(), points, tol, *d),+ Op::Thicken(s, t, sym) => thicken(&s.core(), *t, *sym),+ Op::OffsetSheet(s, d) => offset_sheet(&s.core(), *d),+ Op::Draft(s, points, o, n, pull, angle) => draft(&s.core(), points, tol, *o, *n, *pull, *angle),+ }+}++/// Runs `f` on its own thread: a hang fails the test instead of stopping the run.+fn timed<T: Send + 'static>(name: &str, f: impl FnOnce() -> T + Send + 'static) -> T {+ let (tx, rx) = mpsc::channel();+ let worker = std::thread::spawn(move || {+ let _ = tx.send(f());+ });+ match rx.recv_timeout(TIMEOUT) {+ Ok(v) => v,+ Err(mpsc::RecvTimeoutError::Disconnected) => match worker.join() {+ Err(p) => std::panic::resume_unwind(p),+ Ok(()) => panic!("{name}: no result"),+ },+ Err(mpsc::RecvTimeoutError::Timeout) => panic!("{name}: solidcore hung (no result after {TIMEOUT:?})"),+ }+}++type Got = std::result::Result<Measured, Error>;++fn near(a: [f64; 3], b: [f64; 3]) -> bool {+ a.iter().zip(&b).all(|(x, y)| (x - y).abs() < 1e-6)+}++/// Checks a kernel's result against the case's closed form; what it measured, or its error.+fn judge(name: &str, who: &str, expect: &Expect, got: Got) -> Got {+ match (expect, &got) {+ (Expect::Fails(e), Err(g)) => assert_eq!(g, e, "{name}: {who} failed otherwise"),+ (Expect::Fails(e), Ok(m)) => panic!("{name}: {who} gave {m:?}, expected {e:?}"),+ (_, Err(g)) => panic!("{name}: {who} failed: {g}"),+ (Expect::Volume(v), Ok(m)) => assert!(rel(m.size, *v) < 1e-9, "{name}: {who} volume {} vs analytic {v}", m.size),+ (Expect::Slab(v, lo, hi), Ok(m)) => {+ assert!(rel(m.size, *v) < 1e-9, "{name}: {who} volume {} vs analytic {v}", m.size);+ let (a, b) = (m.bounds.0[2], m.bounds.1[2]);+ assert!((a - lo).abs() < 1e-6 && (b - hi).abs() < 1e-6, "{name}: {who} z from {a} to {b}, expected {lo} to {hi}");+ }+ (Expect::Solid(v, lo, hi), Ok(m)) => {+ assert!(rel(m.size, *v) < 1e-9, "{name}: {who} volume {} vs analytic {v}", m.size);+ assert!(near(m.bounds.0, *lo) && near(m.bounds.1, *hi), "{name}: {who} bounds {:?}, expected {lo:?} {hi:?}", m.bounds);+ }+ (Expect::Sheet(s, lo, hi), Ok(m)) => {+ assert!(rel(m.size, *s) < 1e-9, "{name}: {who} area {} vs analytic {s}", m.size);+ assert!(near(m.bounds.0, *lo) && near(m.bounds.1, *hi), "{name}: {who} bounds {:?}, expected {lo:?} {hi:?}", m.bounds);+ }+ }+ got+}++fn solidcore_case(name: &'static str) -> Got {+ timed(name, move || {+ let c = case(name);+ let sheet = is_sheet(&c.expect);+ let got = on_core(name, &c).map(|body| {+ let size = if sheet { area(&body, 1e-8) } else { volume(&body, 1e-8) }.unwrap_or_else(|e| panic!("{name}: size: {e}"));+ let n = counts(&body).unwrap();+ let (rec, _) = native(&to_arrays(&body).unwrap()).unwrap_or_else(|e| panic!("{name}: record: {e:?}"));+ rec.validate().unwrap_or_else(|e| panic!("{name}: record: {e}"));+ let bx = bounds(&body).unwrap();+ Measured { size, bounds: bx, counts: n, kinds: kinds(&rec) }+ });+ judge(name, "solidcore", &c.expect, got)+ })+}++/// The case on the C++ kernel, called directly (whatever the choice).+#[cfg(feature = "native")]+fn cpp_case(name: &str) -> Got {+ use crate::ops::pick_error;+ use crate::sweeps::DraftCorner;+ use crate::{Brep, error, ffi};+ crate::init().unwrap();+ let line = |a: [f64; 3], b: [f64; 3]| crate::sweeps::Curve::Line { start: a, end: b };+ let make = |s: Shape| -> Brep {+ match s {+ Shape::Box(o, z) => ffi::make_box(&o, &z).map(Brep::made).unwrap(),+ Shape::Cylinder(o, r, h) => ffi::make_cylinder(&o, r, h).map(Brep::made).unwrap(),+ Shape::Sphere(o, r) => ffi::make_sphere(&o, r).map(Brep::made).unwrap(),+ Shape::Frustum(o, a, b, h) => ffi::make_cone(&o, a, b, h).map(Brep::made).unwrap(),+ Shape::LineSheet(a, b, dir, dist) => Brep::extrude(&[line(a, b)], dir, dist, 0.0, DraftCorner::default(), false).unwrap(),+ Shape::ArcSheet(o, r, degrees, h) => {+ let arc = crate::sweeps::Curve::Arc {+ center: o,+ axis: [0.0, 0.0, 1.0],+ reference: [1.0, 0.0, 0.0],+ radius: r,+ start: 0.0,+ end: degrees.to_radians(),+ };+ Brep::extrude(&[arc], [0.0, 0.0, 1.0], h, 0.0, DraftCorner::default(), false).unwrap()+ }+ Shape::Notched => {+ let block = ffi::make_box(&[0.0; 3], &[60.0, 40.0, 10.0]).unwrap();+ let pin = ffi::make_cylinder(&[22.5, 7.0, -5.0], 3.0, 20.0).unwrap();+ let notch = ffi::make_box(&[25.0, -5.0, -5.0], &[10.0, 10.0, 20.0]).unwrap();+ let a = ffi::ops::boolean(&block, &pin, ffi::ops::BOOLEAN_SUBTRACT).unwrap();+ Brep::made(ffi::ops::boolean(&a, ¬ch, ffi::ops::BOOLEAN_SUBTRACT).unwrap())+ }+ }+ };+ let c = case(name);+ let tol = tolerance(name);+ let r = match &c.op {+ Op::Shell(s, points, t) => ffi::ops::pick_op(ffi::ops::Pick::Shell, make(*s).cpp().unwrap(), points, tol, *t).map_err(pick_error),+ Op::OffsetFaces(s, points, d) => ffi::ops::pick_op(ffi::ops::Pick::OffsetFaces, make(*s).cpp().unwrap(), points, tol, *d).map_err(pick_error),+ Op::Thicken(s, t, sym) => ffi::ops::thicken(make(*s).cpp().unwrap(), *t, *sym).map_err(error),+ Op::OffsetSheet(s, d) => ffi::sheets::offset_sheet(make(*s).cpp().unwrap(), *d).map_err(error),+ Op::Draft(s, points, o, n, pull, angle) => ffi::ops::draft(make(*s).cpp().unwrap(), points, tol, o, n, pull, *angle).map_err(pick_error),+ };+ let sheet = is_sheet(&c.expect);+ let got = r.map(|h| {+ let size = if sheet { ffi::measure::area(&h, 1e-8) } else { ffi::volume(&h, 1e-8) }.unwrap();+ let n = ffi::counts(&h).unwrap().map(|x| usize::try_from(x).unwrap());+ let bx = ffi::measure::bounds(&h).unwrap();+ let b = Brep::made(h);+ let (rec, _) = native(&b.cpp_arrays().unwrap()).unwrap();+ rec.validate().unwrap();+ Measured { size, bounds: bx, counts: n, kinds: kinds(&rec) }+ });+ judge(name, "C++", &c.expect, got)+}++/// solidcore and C++ agree: volume (area) within 1e-9, the same counts and faces by kind, or the+/// same error.+#[cfg(feature = "native")]+fn parity(name: &'static str) {+ let cpp = cpp_case(name);+ let ours = solidcore_case(name);+ match (ours, cpp) {+ (Ok(a), Ok(b)) => {+ assert!(rel(a.size, b.size) < 1e-9, "{name}: solidcore {} vs C++ {}", a.size, b.size);+ assert_eq!(a.counts, b.counts, "{name}: face, edge, vertex counts (solidcore vs C++)");+ assert_eq!(a.kinds, b.kinds, "{name}: faces by surface kind (solidcore vs C++)");+ }+ (a, b) => assert_eq!(a.err(), b.err(), "{name}: errors (solidcore vs C++)"),+ }+}++macro_rules! cases {+ ($($m:ident $(: $ign:meta)?),* $(,)?) => {$(+ mod $m {+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_closed_form() {+ let _ = super::solidcore_case(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ super::parity(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ fn the_cpp_kernel_matches_the_closed_form() {+ let _cpp = crate::route::on_cpp();+ let _ = super::cpp_case(stringify!($m));+ }+ }+ )*};+}++cases!(+ shell_box_open_top,+ shell_box_closed,+ shell_box_closed_outward,+ shell_box_outward,+ shell_cylinder_open_top,+ shell_too_thick,+ shell_walls_touch,+ shell_pick_near_nothing,+ shell_pick_ambiguous,+ thicken_plate,+ thicken_plate_symmetric,+ thicken_a_solid,+ offset_sheet_plate,+ offset_sheet_quarter_cylinder,+ offset_sheet_a_solid,+ offset_sheet_a_sphere,+ offset_sheet_a_sphere_to_its_centre,+ offset_faces_top_out,+ offset_faces_through,+ draft_box_sides,+ draft_one_side,+ draft_one_side_out,+ draft_one_side_hinged_at_the_top,+ draft_a_curved_face,+ draft_a_cone_about_the_pull,+ draft_a_face_across_the_pull,+);++/// The capi's argument checks, before any kernel call.+#[test]+fn hostile_arguments_are_refused() {+ let b = BLOCK.core();+ for t in [0.0, f64::NAN, -1e7, f64::INFINITY] {+ assert_eq!(shell(&b, &[TOP], TOL, t).err(), Some(Error::Argument), "thickness {t}");+ assert_eq!(thicken(&b, t, false).err(), Some(Error::Argument), "thickness {t}");+ assert_eq!(offset_sheet(&b, t).err(), Some(Error::Argument), "distance {t}");+ assert_eq!(offset_faces(&b, &[TOP], TOL, t).err(), Some(Error::Argument), "distance {t}");+ }+ assert_eq!(shell(&b, &[[f64::NAN; 3]], TOL, -1.0).err(), Some(Error::Argument));+ assert_eq!(shell(&b, &[TOP], 0.0, -1.0).err(), Some(Error::Argument));+ assert_eq!(offset_faces(&b, &[], TOL, 1.0).err(), Some(Error::Argument));+ let z = [0.0, 0.0, 1.0];+ assert_eq!(draft(&b, &[TOP], TOL, [0.0; 3], [0.0; 3], z, 0.1).err(), Some(Error::Argument), "no neutral normal");+ assert_eq!(draft(&b, &[TOP], TOL, [0.0; 3], z, z, 0.0).err(), Some(Error::Argument), "no angle");+ assert_eq!(draft(&b, &[TOP], TOL, [0.0; 3], z, z, PI / 2.0).err(), Some(Error::Argument), "a right angle");+ assert_eq!(draft(&b, &[TOP], TOL, [f64::NAN; 3], z, z, 0.1).err(), Some(Error::Argument));+}++/// The body offset is never changed.+#[test]+fn the_body_stays_as_it_was() {+ let r = timed("operand", || {+ let b = BLOCK.core();+ let _ = shell(&b, &[TOP], TOL, -2.0);+ (counts(&b).unwrap(), volume(&b, 1e-8).unwrap())+ });+ assert_eq!(r.0, [6, 12, 8]);+ assert!(rel(r.1, ABC) < 1e-12, "{}", r.1);+}++/// The distance from `p` to each face of `b` (`SmApiFaceClosestPoint`), under `identity`.+fn face_distances(+ k: &mut solidcore::kernel::Kernel,+ b: &mut solidcore::topology::Brep,+ identity: &solidcore::query::brep::BrepIdentity<'_>,+ p: Vec3,+) -> solidcore::Result<Vec<(f64, Vec3)>> {+ use solidcore::geom::object::Shape as Sh;+ use solidcore::query::api_queries::face_closest_point_in_shape;+ use solidcore::query::brep::LiveBrepObjects;+ use solidcore::topology::BrepId;+ let one = BrepId::from_index(0);+ let mut out = Vec::new();+ for f in solidcore::topology::brep::p1::faces(b, None)? {+ let shape = Sh::new(k, &(one, &*b), &[], &[(one, f)], &[], &[])?;+ let objects = LiveBrepObjects::new(b, identity, None)?;+ let c = face_closest_point_in_shape(k, &shape, &objects, (one, f), p)?;+ out.push((c.distance, c.point));+ }+ Ok(out)+}++/// The closed form for (15, 10, 20) above the 30 x 20 x 10 box at the origin, face by face of+/// `create_box`: bottom 20, top 10, the x sides sqrt(15^2 + 10^2), the y sides sqrt(10^2 + 10^2).+fn box_face_distances_are_exact(what: &str, d: &[(f64, Vec3)]) {+ let want = [20.0, 10.0, 325f64.sqrt(), 325f64.sqrt(), 200f64.sqrt(), 200f64.sqrt()];+ assert_eq!(d.len(), want.len(), "{what}: faces");+ for (i, (&(got, _), want)) in d.iter().zip(want).enumerate() {+ assert!((got - want).abs() < 1e-9, "{what}: face {i} at {got}, want {want}");+ }+ let top = d[1].1;+ assert!((top.x - 15.0).abs() < 1e-9 && (top.y - 10.0).abs() < 1e-9 && (top.z - 10.0).abs() < 1e-9, "{what}: top {top:?}");+}++/// Picking faces on a solidcore box: on the body itself, on the working copy every operation+/// makes (`brep_copy`), and by solidcore's recommended usage, each face's distance is the closed+/// form and the top face is picked.+#[test]+fn faces_are_picked_on_the_box_and_on_its_working_copy() {+ use solidcore::query::brep::{BrepIdentity, BrepQuery};+ let p = Vec3::new(15.0, 10.0, 20.0);+ let on_top = [[15.0, 10.0, 10.0]];+ run("pick", |k| {+ let mut b = solidcore::primitive::api_primitives::create_box(k, Vec3::new(0.0, 0.0, 0.0), 30.0, 20.0, 10.0)?;+ let mut w = solidcore::topology::brep::p3::brep_copy(k, &b)?;+ let mut faces = Vec::new();+ for (what, x) in [("the body", &mut b), ("its copy", &mut w)] {+ let query = BrepQuery::of_brep(x);+ let identity = query.effective_identity();+ box_face_distances_are_exact(what, &face_distances(k, x, &identity, p)?);+ let picked = super::offset::pick_faces(k, x, &on_top, TOL)?;+ faces.push(picked.ok());+ }+ assert!(faces[0].as_ref().is_some_and(|f| f.len() == 1), "the body: {faces:?}");+ assert_eq!(faces[0], faces[1], "the body and its copy pick the same face");+ // `BrepIdentity::of_brep` honours a copy's owner keys since solidcore#1445: the body+ // and its copy both resolve.+ for (what, x) in [("of_brep on the body", &mut b), ("of_brep on its copy", &mut w)] {+ let proven = BrepIdentity::of_brep(x);+ box_face_distances_are_exact(what, &face_distances(k, x, &proven.identity(), p)?);+ }+ Ok(())+ })+ .unwrap();+}++/// A pick skips an entity whose query returns an SMLib status, as the capi skips any status+/// other than `SM_SUCCESS`; any other solidcore error fails the pick.+#[test]+fn a_solidcore_error_in_a_pick_is_an_error() {+ use super::answer;+ use super::blend::pick;+ use solidcore::SolidError;+ let all = [0usize, 1];+ let points = [[0.0; 3]];+ let status = pick(&all, &points, 1.0, 1e-6, |i, _| answer(if i == 0 { Err(SolidError::sm_err("q")) } else { Ok(0.5) }));+ assert_eq!(status.unwrap().unwrap().0, vec![1], "a status skips the entity");+ let other = pick(&all, &points, 1.0, 1e-6, |i, _| answer(if i == 0 { Err(SolidError::invalid_input("q", "owner")) } else { Ok(0.5) }));+ assert!(matches!(other, Err(SolidError::InvalidInput { .. })), "{other:?}");+ let unported = pick(&all, &points, 1.0, 1e-6, |i, _| answer(if i == 0 { Err(SolidError::unported("Sm::X", "u")) } else { Ok(0.5) }));+ assert!(matches!(unported, Err(SolidError::Unported { .. })), "{unported:?}");+}++/// The capi's `moved_faces` reading: no mark, no move (SMLIB_ERR_NO_EFFECT); a mark is read once,+/// and gone.+#[test]+fn a_draft_with_no_marked_face_left_has_no_effect() {+ let body = make_box([0.0; 3], [10.0; 3]).unwrap();+ super::with_body("marks", &body, |_, w| {+ assert!(!moved_faces(w)?, "no face marked");+ let f = w.face_list()[0];+ mark_moved(w, &[f])?;+ assert!(moved_faces(w)?, "a face marked");+ assert!(!moved_faces(w)?, "the mark removed");+ Ok(())+ })+ .unwrap();+}++/// A draft leaves no mark of its own on what it returns, on a plane or on a cylinder turned cone.+#[test]+fn a_draft_leaves_no_mark() {+ let z = [0.0, 0.0, 1.0];+ let bx = make_box([0.0; 3], [20.0, 30.0, 10.0]).unwrap();+ let plane = draft(&bx, &[[10.0, 0.0, 5.0]], TOL, [0.0; 3], z, z, 0.1).unwrap();+ let cyl = make_cylinder([0.0; 3], 5.0, 10.0).unwrap();+ let cone = draft(&cyl, &[[5.0, 0.0, 5.0]], TOL, [0.0; 3], z, z, 0.1).unwrap();+ for b in [plane, cone] {+ super::with_body("marks", &b, |_, w| {+ assert!(!moved_faces(w)?);+ Ok(())+ })+ .unwrap();+ }+}++/// `moved_faces` on both kernels: drafts so small they leave a plane or cylinder where it was+/// still moved a face (SMLib's mark and solidcore's both stay on it), an angle that brings a wall+/// onto the plane of the wall above it leaves the two faces apart, and no draft here is+/// SMLIB_ERR_NO_EFFECT on either: the same answer, volume and counts. The C++ check holds a local+/// operation to what it promised and no body found so far trips it.+#[cfg(feature = "native")]+#[test]+fn a_draft_moves_a_face_as_on_cpp() {+ let _cpp = crate::route::on_cpp();+ use crate::sweeps::{Curve, DraftCorner};+ use crate::{Brep, ffi};+ crate::init().unwrap();+ let z = [0.0, 0.0, 1.0];+ let make = |h: ffi::Handle| Brep::made(h);+ let plate = make(ffi::make_box(&[0.0; 3], &[40.0, 40.0, 10.0]).unwrap());+ let rod = make(ffi::make_cylinder(&[20.0, 20.0, -5.0], 5.0, 30.0).unwrap());+ let holed = make(ffi::ops::boolean(plate.cpp().unwrap(), rod.cpp().unwrap(), ffi::ops::BOOLEAN_SUBTRACT).unwrap());+ let pinned = make(ffi::ops::boolean(plate.cpp().unwrap(), rod.cpp().unwrap(), ffi::ops::BOOLEAN_UNION).unwrap());+ let t = 5f64.to_radians().tan();+ // A wall x = 20 up to z = 10, then a wall leaning in 5 degrees: the lower wall turned 5+ // degrees about z = 10 lies on the upper one's plane.+ let p = [[0.0, 0.0, 0.0], [20.0, 0.0, 0.0], [20.0, 0.0, 10.0], [20.0 - 10.0 * t, 0.0, 20.0], [0.0, 0.0, 20.0]];+ let profile: Vec<Curve> = (0..5).map(|i| Curve::Line { start: p[i], end: p[(i + 1) % 5] }).collect();+ crate::sweeps::ON_CPP.with(|c| c.set(true));+ let leaning = Brep::extrude(&profile, [0.0, 1.0, 0.0], 10.0, 0.0, DraftCorner::default(), true).unwrap();+ crate::sweeps::ON_CPP.with(|c| c.set(false));+ let five = 5f64.to_radians();+ let cases: [(&str, &Brep, [f64; 3], [f64; 3], f64); 7] = [+ ("tiny on a plane", &plate, [20.0, 0.0, 5.0], [0.0; 3], 1e-14),+ ("tiny on a hole", &holed, [25.0, 20.0, 5.0], [0.0, 0.0, 5.0], 1e-14),+ ("tiny on a pin", &pinned, [25.0, 20.0, 20.0], [0.0, 0.0, 5.0], -1e-14),+ ("small on a hole", &holed, [25.0, 20.0, 5.0], [0.0, 0.0, 5.0], 1e-6),+ ("onto the wall above", &leaning, [20.0, 5.0, 5.0], [0.0, 0.0, 10.0], five),+ ("away from the wall above", &leaning, [20.0, 5.0, 5.0], [0.0, 0.0, 10.0], -five),+ ("hinged far off", &plate, [20.0, 0.0, 5.0], [0.0, 0.0, 1000.0], five),+ ];+ for (name, b, at, origin, angle) in cases {+ let cpp = ffi::ops::draft(b.cpp().unwrap(), &[at], TOL, &origin, &z, &z, angle).unwrap();+ let (v, n) = (ffi::volume(&cpp, 1e-8).unwrap(), ffi::counts(&cpp).unwrap().map(|x| usize::try_from(x).unwrap()));+ let core = draft(b.core().unwrap(), &[at], TOL, origin, z, z, angle).unwrap();+ let w = volume(&core, 1e-8).unwrap();+ assert!(rel(w, v) < 1e-9, "{name}: solidcore {w} vs C++ {v}");+ assert_eq!(counts(&core).unwrap(), n, "{name}");+ }+}++/// The tip cut off a triangular prism, drafted about a plane 100 mm off so that the whole face goes+/// out past where its neighbours meet: its edges vanish, `SM_ERR_OFFSET_EDGE_VANISHES` in SMLib,+/// which the capi's `status` answers as `SMLIB_ERR_UNSUPPORTED`, on both kernels.+#[cfg(feature = "native")]+#[test]+fn a_draft_past_the_neighbours_meeting_is_unsupported_as_on_cpp() {+ let _cpp = crate::route::on_cpp();+ use crate::sweeps::{Curve, DraftCorner};+ use crate::{Brep, ffi};+ crate::init().unwrap();+ let p = [[0.0, 0.0, 0.0], [20.0, 0.0, 0.0], [11.0, 18.0, 0.0], [9.0, 18.0, 0.0]];+ let profile: Vec<Curve> = (0..4).map(|i| Curve::Line { start: p[i], end: p[(i + 1) % 4] }).collect();+ crate::sweeps::ON_CPP.with(|c| c.set(true));+ let prism = Brep::extrude(&profile, [0.0, 0.0, 1.0], 10.0, 0.0, DraftCorner::default(), true).unwrap();+ crate::sweeps::ON_CPP.with(|c| c.set(false));+ let (tip, z, origin, angle) = ([[10.0, 18.0, 5.0]], [0.0, 0.0, 1.0], [0.0, 0.0, -100.0], (-2f64).to_radians());+ let cpp = ffi::ops::draft(prism.cpp().unwrap(), &tip, TOL, &origin, &z, &z, angle);+ assert_eq!(cpp.err(), Some((ffi::ops::ERR_UNSUPPORTED, None)));+ assert_eq!(draft(prism.core().unwrap(), &tip, TOL, origin, z, z, angle).err(), Some(Error::Unsupported));+}++/// A flat L of two faces thickened by 2 with mitred walls: 2 x 10 x (20 + 22), as the C++ kernel+/// makes it.+#[cfg(feature = "native")]+#[test]+fn an_l_sheet_thickens_as_on_cpp() {+ let _cpp = crate::route::on_cpp();+ use crate::sweeps::{Curve, DraftCorner};+ use crate::{Brep, ffi};+ crate::init().unwrap();+ let l = [Curve::Line { start: [0.0; 3], end: [20.0, 0.0, 0.0] }, Curve::Line { start: [20.0, 0.0, 0.0], end: [20.0, 20.0, 0.0] }];+ crate::sweeps::ON_CPP.with(|c| c.set(true));+ let sheet = Brep::extrude(&l, [0.0, 0.0, 1.0], 10.0, 0.0, DraftCorner::default(), false).unwrap();+ crate::sweeps::ON_CPP.with(|c| c.set(false));+ let cpp = ffi::ops::thicken(sheet.cpp().unwrap(), 2.0, false).unwrap();+ assert!(rel(ffi::volume(&cpp, 1e-8).unwrap(), 840.0) < 1e-9);+ let core = thicken(sheet.core().unwrap(), 2.0, false).unwrap();+ assert!(rel(volume(&core, 1e-8).unwrap(), 840.0) < 1e-9);+}++/// Face and edge tags (`Brep::tagged`) through offsets on solidcore, as on C++: the box is+/// tagged on the C++ kernel, its solidcore body converted from that and tagged the same way, and+/// the two results' histories must be the same.+#[cfg(feature = "native")]+mod history {+ use crate::{Brep, ffi};++ fn tagged_box() -> Brep {+ crate::init().unwrap();+ Brep::made(ffi::make_box(&[0.0; 3], &[20.0, 30.0, 10.0]).unwrap()).tagged(0).unwrap()+ }++ /// The box hollowed to 2 mm walls, its top open: the five walls offset inward stand for the+ /// faces they offset.+ #[test]+ fn tags_cross_a_shell() {+ let _cpp = crate::route::on_cpp();+ let a = tagged_box();+ let top = [[10.0, 15.0, 10.0]];+ let cpp = Brep::made(ffi::ops::pick_op(ffi::ops::Pick::Shell, a.cpp().unwrap(), &top, super::TOL, -2.0).unwrap()).history().unwrap();+ let core = Brep::made_core(super::shell(a.core().unwrap(), &top, super::TOL, -2.0).unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ }++ /// The top moved down 2 mm: it stands for itself, its four neighbours are trimmed to meet it.+ #[test]+ fn tags_cross_a_face_offset() {+ let _cpp = crate::route::on_cpp();+ let a = tagged_box();+ let top = [[10.0, 15.0, 10.0]];+ let cpp = Brep::made(ffi::ops::pick_op(ffi::ops::Pick::OffsetFaces, a.cpp().unwrap(), &top, super::TOL, -2.0).unwrap()).history().unwrap();+ let core = Brep::made_core(super::offset_faces(a.core().unwrap(), &top, super::TOL, -2.0).unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ }++ /// A flat sheet and a half-round open extrusion, tagged on the C++ kernel.+ fn tagged_sheet(curved: bool) -> Brep {+ use std::f64::consts::PI;++ use crate::sweeps::{Curve, DraftCorner};+ crate::init().unwrap();+ crate::sweeps::ON_CPP.with(|c| c.set(true));+ let b = if curved {+ let arc = [Curve::Arc { center: [0.0; 3], axis: [0.0, 0.0, 1.0], reference: [1.0, 0.0, 0.0], radius: 10.0, start: 0.0, end: PI }];+ Brep::extrude(&arc, [0.0, 0.0, 1.0], 20.0, 0.0, DraftCorner::default(), false)+ } else {+ let c = [[0.0, 0.0, 0.0], [20.0, 0.0, 0.0], [20.0, 10.0, 0.0], [0.0, 10.0, 0.0]];+ let l: Vec<Curve> = (0..4).map(|i| Curve::Line { start: c[i], end: c[(i + 1) % 4] }).collect();+ Brep::planar_faces(&l)+ };+ crate::sweeps::ON_CPP.with(|c| c.set(false));+ b.unwrap().tagged(0).unwrap()+ }++ /// A sheet thickened to one side and to both: both faces stand for the sheet's (the histories+ /// `offset_backend` reads), its edges and their offsets for its edges, the walls for nothing.+ fn thicken_parity(curved: bool) {+ for symmetric in [false, true] {+ let a = tagged_sheet(curved);+ let cpp = Brep::made(ffi::ops::thicken(a.cpp().unwrap(), 2.0, symmetric).unwrap()).history().unwrap();+ let core = Brep::made_core(super::thicken(a.core().unwrap(), 2.0, symmetric).unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical(), "symmetric {symmetric}");+ }+ }++ #[test]+ fn tags_cross_a_thicken_of_a_curved_sheet() {+ let _cpp = crate::route::on_cpp();+ thicken_parity(true);+ }++ #[test]+ fn tags_cross_a_thicken_of_a_flat_sheet() {+ let _cpp = crate::route::on_cpp();+ thicken_parity(false);+ }++ /// A sheet moved along its normal, flat and curved: each face stands for itself.+ #[test]+ fn tags_cross_a_sheet_offset() {+ let _cpp = crate::route::on_cpp();+ for curved in [false, true] {+ let a = tagged_sheet(curved);+ let cpp = Brep::made(ffi::sheets::offset_sheet(a.cpp().unwrap(), 1.5).unwrap()).history().unwrap();+ let core = Brep::made_core(super::offset_sheet(a.core().unwrap(), 1.5).unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical(), "curved {curved}");+ }+ }++ /// A cylinder hollowed, its top open: the walls round closed edges, on a curved face.+ #[test]+ fn tags_cross_a_shell_of_a_cylinder() {+ let _cpp = crate::route::on_cpp();+ crate::init().unwrap();+ let a = Brep::made(ffi::make_cylinder(&[0.0; 3], 10.0, 20.0).unwrap()).tagged(0).unwrap();+ let top = [[0.0, 0.0, 20.0]];+ let cpp = Brep::made(ffi::ops::pick_op(ffi::ops::Pick::Shell, a.cpp().unwrap(), &top, super::TOL, -2.0).unwrap()).history().unwrap();+ let core = Brep::made_core(super::shell(a.core().unwrap(), &top, super::TOL, -2.0).unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ }++ /// A 5 degree draft of the front about the bottom plane: the front tilts, its neighbours'+ /// edges move with it.+ #[test]+ fn tags_cross_a_draft() {+ let _cpp = crate::route::on_cpp();+ let a = tagged_box();+ let front = [[10.0, 0.0, 5.0]];+ let (origin, normal, pull, angle) = ([0.0; 3], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0], 5f64.to_radians());+ let cpp = ffi::ops::draft(a.cpp().unwrap(), &front, super::TOL, &origin, &normal, &pull, angle).unwrap();+ let cpp = Brep::made(cpp).history().unwrap();+ let core = Brep::made_core(super::draft(a.core().unwrap(), &front, super::TOL, origin, normal, pull, angle).unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ }+}++/// A stepped block, 40 x 30 x 10 with its half x < 20 raised to 20 (rig case+/// shell/cov-replace-face-step-onto-the-higher-face, the fork's `offset_faces_close_a_step_wall`):+/// a top moved onto the other's plane closes the step wall between them to nothing, and the tops+/// are one face of a 6-faced box.+#[test]+fn offset_faces_close_a_step_wall() {+ use super::boolean::boolean;+ let stepped = boolean(&make_box([0.0; 3], [40.0, 30.0, 10.0]).unwrap(), &make_box([0.0; 3], [20.0, 30.0, 20.0]).unwrap(), BooleanOp::Union)+ .unwrap()+ .unwrap();+ assert_eq!(counts(&stepped).unwrap()[0], 8);+ for (at, d, v, a) in [([30.0, 15.0, 10.0], 10.0, 24000.0, 5200.0), ([10.0, 15.0, 20.0], -10.0, 12000.0, 3800.0)] {+ let r = offset_faces(&stepped, &[at], 0.1, d).unwrap();+ let (got, n, area) = (volume(&r, 1e-8).unwrap(), counts(&r).unwrap(), super::area(&r, 1e-8).unwrap());+ assert_eq!(n[0], 6, "d {d}");+ assert!(rel(got, v) < 1e-9 && rel(area, a) < 1e-9, "d {d}: V {got} A {area}");+ }+}++/// Rig case shell/4492's rounded box: four mitred rounds, r 3, come off a 40 x 30 x 10 box's top+/// together and follow it. From height 0 the outline is the 34 x 24 top moved out by the round's+/// w(z) = sqrt(9 - (z - axis)^2), or 3 below the axis. With the fork's values at +19, and bodies+/// whose rounds go all the way down from -7 and are cut short from -7.5 (solidcore#2027). At -9+/// solidcore refuses to put the rounds back (solidcore#2020, open): SolidCraft says it does not+/// make that move, where the C++ kernel gives the analytic value, also checked here. With SMLib+/// built, the C++ kernel gives the same at every other move.+#[cfg(feature = "native")]+#[test]+fn mitred_rounds_follow_a_moved_top() {+ let _cpp = crate::route::on_cpp();+ mitred_rounds_follow_a_moved_top_check();+}++/// The same on a build without the C++ kernel: solidcore's half alone. A test of its own, so that+/// tests/KNOWN_FAILING_TESTS's entry for the C++ comparison (mitred_rounds_follow_a_moved_top) is graded only where it runs.+#[cfg(not(feature = "native"))]+#[test]+fn mitred_rounds_follow_a_moved_top_on_solidcore() {+ mitred_rounds_follow_a_moved_top_check();+}++fn mitred_rounds_follow_a_moved_top_check() {+ use super::blend::{Corners, blend};+ use crate::Blend;+ let edges = [[20.0, 0.0, 10.0], [20.0, 30.0, 10.0], [0.0, 15.0, 10.0], [40.0, 15.0, 10.0]];+ let top = [20.0, 15.0, 10.0];+ let rounded = blend(&make_box([0.0; 3], [40.0, 30.0, 10.0]).unwrap(), Blend::Round, &edges, &[3.0; 4], TOL, &[], &[], Corners::Filled).unwrap();+ let analytic = |d: f64| {+ let (height, axis, n) = (10.0 + d, 7.0 + d, 20000);+ (0..n)+ .map(|i| {+ let z = height * (f64::from(i) + 0.5) / f64::from(n);+ let w = if z < axis { 3.0 } else { (9.0 - (z - axis) * (z - axis)).max(0.0).sqrt() };+ (34.0 + 2.0 * w) * (24.0 + 2.0 * w) * height / f64::from(n)+ })+ .sum::<f64>()+ };+ let moves = [+ (19.0, [10, 20, 12]),+ (1.0, [10, 20, 12]),+ (-1.0, [10, 20, 12]),+ (-6.9, [10, 20, 12]),+ (-7.0, [6, 12, 8]),+ (-7.5, [6, 12, 8]),+ (-8.0, [6, 12, 8]),+ (-9.5, [6, 12, 8]),+ ];+ for (d, n) in moves {+ let moved = offset_faces(&rounded, &[top], 0.1, d).unwrap();+ let v = volume(&moved, 1e-8).unwrap();+ assert_eq!(counts(&moved).unwrap(), n, "d {d}");+ assert!(rel(v, analytic(d)) < 1e-6, "d {d}: {v} vs {}", analytic(d));+ }+ assert!(matches!(offset_faces(&rounded, &[top], 0.1, -9.0), Err(Error::Unsupported)));+ #[cfg(feature = "native")]+ {+ use crate::ffi;+ crate::init().unwrap();+ let b = ffi::make_box(&[0.0; 3], &[40.0, 30.0, 10.0]).unwrap();+ let round = ffi::ops::blend(ffi::ops::BLEND_ROUND, &b, &edges, &[3.0; 4], TOL).unwrap();+ for (d, _) in moves {+ let cpp = ffi::ops::pick_op(ffi::ops::Pick::OffsetFaces, &round, &[top], 0.1, d).unwrap();+ let ours = offset_faces(&rounded, &[top], 0.1, d).unwrap();+ let (o, c) = (volume(&ours, 1e-8).unwrap(), ffi::volume(&cpp, 1e-8).unwrap());+ // Below -7 the rounds are cut short: both are within 1e-6 of the analytic value, and at+ // -7.5 within 4.7e-9 of each other.+ let agree = if d < -7.0 { 1e-8 } else { 1e-9 };+ assert!(rel(o, c) < agree, "d {d}: {o} vs the C++ kernel's {c}");+ }+ // At -9 the C++ kernel at 26cc451 refuses it too.+ assert!(ffi::ops::pick_op(ffi::ops::Pick::OffsetFaces, &round, &[top], 0.1, -9.0).is_err(), "d -9");+ }+}diff --git a/crates/smlib/src/core/split.rs b/crates/smlib/src/core/split.rsnew file mode 100644index 0000000000..f39044404d--- /dev/null+++ b/crates/smlib/src/core/split.rs@@ -0,0 +1,513 @@+//! Split Face and Split Body on solidcore: the C API's composition, ported from the fork's+//! `capi/src/smlib_split.cpp` (`smlib_split_faces`, `smlib_split_body`, `cut_face`,+//! `plane_covers`, `slice`, `both_sides`, `smlib_split_body_by_sheet`) and the tool surfaces of `capi/src/smlib_ssi.cpp`+//! (`smlib_surface_plane`, `_cylinder`, `_cone`, `_sphere`, `_torus`, `_nurbs`).+//!+//! As there, every operation works on copies of its body (`SmApiBrepCopy`). A face is cut where+//! a tool meets it the way SMLib's plane cutter cuts a subset of faces: the face's surface is+//! intersected with the tool over the face's UV domain (`CreatePlanarSectionCurves` for a plane+//! reaching over the face, `GlobalSurfaceIntersect` otherwise) and the untrimmed curves go to+//! `SmBrep::MergeCurvesOnSurface` with the tool as the intersecting surface. Unlike the plane+//! cutter, a failed merge fails the call. A body is split by slicing (`SM_BO_SLICE`) copies of it+//! with a one-face sheet on the tool surface, once with the surface turned over; or with a sheet+//! of several faces as it is, its surfaces first turned to agree.+//!+//! A tool is a [`crate::ssi::Surface`]; solidcore's own surface is made from its description+//! ([`Spec`]), as `smlib_ssi.cpp` makes SMLib's, over the surface's natural UV domain.++use std::sync::PoisonError;++use solidcore::EntityRef;+use solidcore::boolean::api_brep::boolean_with_options;+use solidcore::boolean::merge::MergeOptions;+use solidcore::geom::a_object::BooleanOperation;+use solidcore::geom::axis2_placement::Axis2Placement;+use solidcore::geom::extent2d::Extent2d;+use solidcore::geom::object::ObjectRef;+use solidcore::geom::tol::{USE_DEFAULT, approx_tol3d};+use solidcore::geom::vector2d::Vec2;+use solidcore::geom::vector3d::{Point3, Vec3};+use solidcore::kernel::Kernel;+use solidcore::nurbs::b_spline_curve::p1::KnotType;+use solidcore::nurbs::b_spline_surface::p1::{BSplineSurface, BSplineSurfaceForm, CanonicalSurfaceData};+use solidcore::nurbs::math::CPoint;+use solidcore::query::brep::BrepFaceServices;+use solidcore::query::face::p1::calculate_bounding_box;+use solidcore::surface::cone::p1::Cone;+use solidcore::surface::plane::p1::Plane;+use solidcore::surface::sphere::{Sphere, SphereOptions};+use solidcore::surface::surface::Surface;+use solidcore::surface::surface::p2::TsectCurveType;+use solidcore::surface::torus::{Torus, TorusOptions};+use solidcore::topology::brep::p1 as brep_p1;+use solidcore::topology::brep::p2::{is_manifold_solid, is_sheet};+use solidcore::topology::brep::p3::{new_brep, with_kernel_callbacks};+use solidcore::topology::brep::p8::create_face_from_surface;+use solidcore::topology::brep::p9::orient_sheet_surfaces;+use solidcore::topology::brep::p10::merge_curves_on_surface_through_surface;+use solidcore::topology::brep::planar_section::face_planar_section_curves;+use solidcore::topology::brep_cache::CacheObject;+use solidcore::topology::edge::NotifyEnv;+use solidcore::topology::face::p2 as face_p2;+use solidcore::topology::{Brep, EdgeId, FaceId};++use super::blend::status;+use super::sweep::build_faces;+use super::{Body, run};+use crate::ssi::Spec;+use crate::{Error, Result};+use solidcore::topology::brep::p3::brep_copy;++/// `SMLIB_SPLIT_MAX_FACES`, `SMLIB_SPLIT_MAX_TOOLS`.+pub(crate) const MAX_FACES: usize = crate::ffi::split::MAX_FACES;+pub(crate) const MAX_TOOLS: usize = crate::ffi::split::MAX_TOOLS;++/// `SM_ERR`.+const SM_ERR: i32 = 1001;++/// The capi's statuses as SolidCraft errors: an operation's own result.+type Out<T> = std::result::Result<T, Error>;++/// A tool surface as solidcore holds it: the surface over its natural UV domain (`smlib_surface`'s+/// `s` and `domain`), and for a plane its point and unit normal (`IsPlanar`).+pub(crate) struct Tool {+ pub(super) surface: Surface,+ pub(super) domain: Extent2d,+ plane: Option<(Point3, Vec3)>,+}++fn v3(p: [f64; 3]) -> Vec3 {+ Vec3::new(p[0], p[1], p[2])+}++/// The runner's `unit_cross`.+fn unit_cross(a: Vec3, b: Vec3) -> Vec3 {+ let c = a.cross(b);+ let l = c.length();+ Vec3::new(c.x / l, c.y / l, c.z / l)+}++/// `[k0, k0, k1, ...]` as unique values and their multiplicities (`unique_knots`).+fn unique_knots(k: &[f64]) -> (Vec<f64>, Vec<usize>) {+ let (mut values, mut mults): (Vec<f64>, Vec<usize>) = (Vec::new(), Vec::new());+ for &x in k {+ match (values.last(), mults.last_mut()) {+ (Some(&last), Some(m)) if last == x => *m += 1,+ _ => {+ values.push(x);+ mults.push(1);+ }+ }+ }+ (values, mults)+}++/// `clamped`: the first and the last knot each p + 1 times.+fn clamped(k: &[f64], p: usize) -> bool {+ match (k.first(), k.get(p), k.last(), k.len().checked_sub(1 + p).and_then(|i| k.get(i))) {+ (Some(a), Some(b), Some(c), Some(d)) => a == b && c == d,+ _ => false,+ }+}++/// The tool's surface as `smlib_ssi.cpp`'s constructors make it, then its natural UV domain+/// (`construct`: finite and not empty, else `SM_ERR_INVALID_INPUT`).+pub(super) fn tool(k: &Kernel, spec: &Spec) -> solidcore::Result<Out<Tool>> {+ let mut plane = None;+ let surface = match spec {+ Spec::Plane { origin, xaxis, yaxis, u, v } => {+ let dom = Extent2d::from_bounds(u[0], v[0], u[1], v[1]);+ plane = Some((v3(*origin), unit_cross(v3(*xaxis), v3(*yaxis))));+ Surface::from(Plane::new(v3(*origin), v3(*xaxis), v3(*yaxis), Vec2::new(1.0, 1.0), &dom))+ }+ Spec::Cylinder { origin, xaxis, yaxis, radius, angle_deg, height } => {+ let (x, y) = (v3(*xaxis), v3(*yaxis));+ let o = v3(*origin) + unit_cross(x, y) * height[0];+ Surface::from(Cone::new_cylinder_bounded(o, x, y, *radius, angle_deg[0], angle_deg[1], height[1] - height[0], false, false, false))+ }+ Spec::Cone { apex, xaxis, yaxis, half_angle_deg, height } => {+ let (x, y) = (v3(*xaxis), v3(*yaxis));+ let (h0, h1) = (height[0], height[1]);+ let t = half_angle_deg.to_radians().tan();+ let o = v3(*apex) + unit_cross(x, y) * h0;+ let pl = Axis2Placement::new(o, x, y);+ Surface::from(Cone::create_canonical(k, &pl, h0 * t, h1 * t, h1 - h0, false, false)?)+ }+ Spec::Sphere { center, xaxis, yaxis, radius, lon_deg, lat_deg } => {+ let anal = Extent2d::from_bounds(lon_deg[0], lat_deg[0], lon_deg[1], lat_deg[1]);+ let opts = SphereOptions { swap_uv: false, inside_out: false, circle_nurb: None };+ Surface::from(Sphere::new(k, v3(*center), v3(*xaxis), v3(*yaxis), anal, *radius, opts)?)+ }+ Spec::Torus { center, xaxis, yaxis, major_radius, minor_radius, major_deg, minor_deg } => {+ let anal = Extent2d::from_bounds(major_deg[0], minor_deg[0], major_deg[1], minor_deg[1]);+ Surface::from(Torus::new(k, v3(*center), v3(*xaxis), v3(*yaxis), anal, *major_radius, *minor_radius, TorusOptions::default())?)+ }+ Spec::Nurbs { degree, nu, nv, knots_u, knots_v, points, weights } => {+ let [p, q] = *degree;+ let w = |i: usize| weights.as_ref().and_then(|w| w.get(i).copied()).unwrap_or(1.0);+ if !clamped(knots_u, p) || !clamped(knots_v, q) {+ // SMLib's component constructor clamps the surface to its domain.+ let (ku, mu) = unique_knots(knots_u);+ let (kv, mv) = unique_knots(knots_v);+ let wts: Vec<f64> = (0..points.len()).map(w).collect();+ let pts: Vec<Point3> = points.iter().map(|p| v3(*p)).collect();+ let data = CanonicalSurfaceData {+ u_degree: p,+ v_degree: q,+ control_points: &pts,+ form: BSplineSurfaceForm::Unspecified,+ u_multiplicities: &mu,+ v_multiplicities: &mv,+ u_knots: &ku,+ v_knots: &kv,+ knot_type: KnotType::Unspecified,+ weights: Some(&wts),+ uv_domain: None,+ };+ Surface::from(BSplineSurface::create_canonical(&data)?)+ } else {+ // The runner's way: the homogeneous net filled directly.+ let mut pw = Vec::with_capacity(*nu);+ for i in 0..*nu {+ let mut row = Vec::with_capacity(*nv);+ for j in 0..*nv {+ let at = i * nv + j;+ let (Some(pt), wt) = (points.get(at), w(at)) else {+ return Ok(Err(Error::Argument));+ };+ row.push(CPoint::new(pt[0] * wt, pt[1] * wt, pt[2] * wt, wt));+ }+ pw.push(row);+ }+ let (n, m) = (nu.saturating_sub(1), nv.saturating_sub(1));+ let (r, s) = (knots_u.len().saturating_sub(1), knots_v.len().saturating_sub(1));+ Surface::from(BSplineSurface::from_data(n, m, p, q, r, s, &pw, knots_u, knots_v)?)+ }+ }+ };+ let domain = surface.natural_uv_domain_with_nurb(k)?;+ let (lo, hi) = (domain.min(), domain.max());+ if !(lo.x.is_finite() && lo.y.is_finite() && hi.x.is_finite() && hi.y.is_finite() && lo.x < hi.x && lo.y < hi.y) {+ return Ok(Err(Error::Status(1007)));+ }+ Ok(Ok(Tool { surface, domain, plane }))+}++/// `plane_covers`: whether the plane `tool` reaches over all of `bx` (each corner's foot on the+/// plane lies in the tool's parameter box): then its section with a face in the box is the+/// infinite plane's.+fn plane_covers(k: &Kernel, tool: &Tool, bx: &solidcore::geom::extent3d::Extent3d, tol: f64) -> bool {+ let (lo, hi) = (tool.domain.min(), tool.domain.max());+ let at = |u: f64, v: f64| tool.surface.evaluate_point(k, Vec2::new(u, v)).ok();+ let (Some(o), Some(pu), Some(pv)) = (at(lo.x, lo.y), at(hi.x, lo.y), at(lo.x, hi.y)) else {+ return false;+ };+ // The plane is affine in (u, v): P = o + (u - u0) X + (v - v0) Y.+ let x = (pu - o) / (hi.x - lo.x);+ let y = (pv - o) / (hi.y - lo.y);+ let (a, b, c) = (x.dot(x), x.dot(y), y.dot(y));+ let det = a * c - b * b;+ if !(det.abs() > 0.0) {+ return false;+ }+ let (m, mm) = (bx.min(), bx.max());+ (0..8).all(|kk| {+ let q = Vec3::new(if kk & 1 != 0 { mm.x } else { m.x }, if kk & 2 != 0 { mm.y } else { m.y }, if kk & 4 != 0 { mm.z } else { m.z });+ let r = q - o;+ let (g0, g1) = (x.dot(r), y.dot(r));+ let u = lo.x + (c * g0 - b * g1) / det;+ let v = lo.y + (a * g1 - b * g0) / det;+ let (su, sv) = (tol / a.sqrt(), tol / c.sqrt());+ u >= lo.x - su && u <= hi.x + su && v >= lo.y - sv && v <= hi.y + sv+ })+}++/// The name of each edge curve a merge makes (`SmApiCut`'s).+fn curve_ref(e: EdgeId, _type_code: i64) -> ObjectRef {+ solidcore::topology::loopuse::notify_ref(EntityRef::Edge(e))+}++/// `cut_face`: cuts `face` where `tool` meets it; the faces it was split into besides itself.+fn cut_face(k: &mut Kernel, b: &mut Brep, env: &mut NotifyEnv<'_>, face: FaceId, tool: &Tool, tol: f64) -> solidcore::Result<Out<Vec<FaceId>>> {+ let Some(surface) = face_p2::surface(b, face)? else {+ return Ok(Err(Error::Status(SM_ERR)));+ };+ let surface = surface.clone_for_evaluation()?;+ let domain = face_p2::uv_domain(b, face)?;+ let approx = approx_tol3d(k, approx_tol3d(k, tol) / 4.0);+ let bx = match calculate_bounding_box(k, &mut *b, face, false) {+ Ok(bx) => bx,+ Err(e) => return Ok(Err(status(e))),+ };+ let merge =+ |k: &mut Kernel, b: &mut Brep, env: &mut NotifyEnv<'_>, mut c3: Vec<_>, uv: Option<Vec<_>>| match merge_curves_on_surface_through_surface(+ k,+ b,+ env,+ &curve_ref,+ face,+ tol,+ &mut c3,+ uv.as_deref(),+ Some(tool.surface.clone()),+ ) {+ Ok((made, _)) => Ok(Ok(made)),+ Err(e) => Ok(Err(status(e))),+ };+ // A plane reaching over the face sections it exactly (SmPlaneCutter's way); a plane strip,+ // like any other tool, is intersected over its own domain.+ if let Some((at, normal)) = tool.plane+ && plane_covers(k, tool, &bx, tol)+ {+ // As SmPlaneCutter: a face far from the plane is not sectioned.+ if bx.distance_to_plane(at, normal).abs() > tol {+ return Ok(Ok(Vec::new()));+ }+ let section = match face_planar_section_curves(k, b, face, &surface, &domain, at, normal, Some(approx), None) {+ Ok(s) => s,+ Err(e) => return Ok(Err(status(e))),+ };+ if section.curves_3d.is_empty() {+ return Ok(Ok(Vec::new()));+ }+ let uv = (section.uv_curves.len() == section.curves_3d.len()).then_some(section.uv_curves);+ return merge(k, b, env, section.curves_3d, uv);+ }+ // `face->GetSurface()` reaches its face's trimmed cache: the solve runs through the B-rep's+ // face services, as solidcore's own face intersections do (a face-owned surface has no cache+ // of its own).+ let mut services = BrepFaceServices::new(&mut *b);+ let found = match surface.global_surface_intersect_with_context(+ k,+ [Some(CacheObject::Surface(face)), None],+ &mut services,+ &domain,+ &tool.surface,+ &tool.domain,+ [true, true],+ Some(approx),+ None,+ ) {+ Ok(f) => f,+ Err(e) => return Ok(Err(status(e))),+ };+ // A single point of contact cuts nothing.+ let (mut c3, mut uv1) = (Vec::new(), Vec::new());+ for (i, c) in found.curves_3d.into_iter().enumerate() {+ if found.curve_types.get(i) == Some(&TsectCurveType::Touching) {+ continue;+ }+ c3.push(c);+ uv1.push(found.surface1_uv_curves.get(i).cloned().flatten());+ }+ if c3.is_empty() {+ return Ok(Ok(Vec::new()));+ }+ let all_uv = uv1.iter().all(Option::is_some);+ merge(k, b, env, c3, all_uv.then_some(uv1))+}++/// `smlib_split_faces`: a copy of `body` with faces `faces` (indices in its face order, distinct)+/// cut where each tool meets them, the tools in turn, each cutting the pieces the earlier ones+/// left; and for each face how many faces it became besides itself. `None` when no face is split+/// (`SMLIB_ERR_NO_CUT`).+pub(crate) fn split_faces(body: &Body, faces: &[usize], tools: &[&Spec]) -> Result<Option<(Body, Vec<usize>)>> {+ if faces.is_empty() || faces.len() > MAX_FACES || tools.is_empty() || tools.len() > MAX_TOOLS {+ return Err(Error::Argument);+ }+ if body.0.is_poisoned() {+ return Err(Error::Internal("smlib_split_faces: the body was left unfinished by an earlier panic".to_owned()));+ }+ let r = run("smlib_split_faces", |k| {+ let mut a = {+ let g = body.0.lock().unwrap_or_else(PoisonError::into_inner);+ super::dump::input(k, "brep", &g);+ let count = brep_p1::faces(&g, None)?.len();+ let mut seen = std::collections::HashSet::new();+ if faces.iter().any(|&f| f >= count || !seen.insert(f)) {+ return Ok(Err(Error::Argument));+ }+ brep_copy(k, &g)?+ };+ let all = brep_p1::faces(&a, None)?;+ // Each chosen face and, as tools cut it, its pieces.+ let mut pieces: Vec<Vec<FaceId>> = Vec::with_capacity(faces.len());+ for &f in faces {+ let Some(&face) = all.get(f) else { return Ok(Err(Error::Status(SM_ERR))) };+ pieces.push(vec![face]);+ }+ let mut made = vec![0usize; faces.len()];+ let mut built = Vec::with_capacity(tools.len());+ for spec in tools {+ match tool(k, spec)? {+ Ok(t) => built.push(t),+ Err(e) => return Ok(Err(e)),+ }+ }+ let editing = a.editing_enabled();+ let doing = k.context.doing_boolean();+ a.set_editing_enabled(true);+ k.context.set_doing_boolean(true);+ let tol = a.tolerance();+ // The edits notify through the kernel's callbacks with the body's own attributes, so+ // the history tags follow each cut (as SMLib's objects notify their attributes).+ let cut = with_kernel_callbacks(k, &mut a, |k, a, env| {+ let mut total = 0usize;+ for t in &built {+ for (i, list) in pieces.iter_mut().enumerate() {+ let now = list.clone();+ for f in now {+ let split = match cut_face(k, a, env, f, t, tol)? {+ Ok(s) => s,+ Err(e) => return Ok(Err(e)),+ };+ if let Some(m) = made.get_mut(i) {+ *m += split.len();+ }+ total += split.len();+ list.extend(split);+ }+ }+ }+ Ok(Ok(total))+ });+ a.set_editing_enabled(editing);+ k.context.set_doing_boolean(doing);+ a.refresh_cached_topology();+ // The cut's new edges own their curves under the kernel's identities (it records them),+ // not the copy's Notify ones, and the check reads the owners by the body's naming.+ a.set_naming(solidcore::topology::NamingScheme::Caller);+ Ok(match cut? {+ Err(e) => Err(e),+ Ok(0) => Ok(None),+ Ok(_) => Ok(Some((a, made))),+ })+ })??;+ Ok(r.map(|(b, made)| (Body::new(b), made)))+}++/// `slice`: a copy of `body` sliced by `sheet` (SMLib's slice reads the side from the surfaces, not+/// the faces' uses). `None` when nothing is left.+fn slice(k: &mut Kernel, body: &Body, sheet: Brep) -> solidcore::Result<Out<Option<Brep>>> {+ let a = {+ let g = body.0.lock().unwrap_or_else(PoisonError::into_inner);+ brep_copy(k, &g)?+ };+ let options = MergeOptions::new(false, false, false, false, false);+ let r = match boolean_with_options(k, a, sheet, BooleanOperation::Slice, options) {+ Ok(r) => r.result,+ Err(e) => return Ok(Err(status(e))),+ };+ Ok(Ok((!r.face_list().is_empty()).then_some(r)))+}++/// `both_sides`: both parts, `side` making each side's sheet (`true`: turned over, for the back).+/// A body that is no manifold solid is [`Error::NotSolid`]; a side left empty is `None`+/// (`SMLIB_ERR_NO_CUT`), and with `whole` so is a part that is no manifold solid: `SM_BO_SLICE`+/// with a sheet that only nicks a region behaves as a difference, leaving the sheet's piece as a+/// slit in the body and a lamina on the other side, which is no cut.+fn both_sides(+ k: &mut Kernel,+ body: &Body,+ whole: bool,+ mut side: impl FnMut(&mut Kernel, bool) -> solidcore::Result<Out<Brep>>,+) -> solidcore::Result<Out<Option<(Brep, Brep)>>> {+ let solid = {+ let g = body.0.lock().unwrap_or_else(PoisonError::into_inner);+ is_manifold_solid(&g)?+ };+ if !solid {+ return Ok(Err(Error::NotSolid));+ }+ let mut parts = [None, None];+ for (part, flip) in parts.iter_mut().zip([true, false]) {+ let sheet = match side(k, flip)? {+ Ok(s) => s,+ Err(e) => return Ok(Err(e)),+ };+ *part = match slice(k, body, sheet)? {+ Ok(p) => p,+ Err(e) => return Ok(Err(e)),+ };+ }+ let [Some(back), Some(front)] = parts else { return Ok(Ok(None)) };+ if whole && !(is_manifold_solid(&back)? && is_manifold_solid(&front)?) {+ return Ok(Ok(None));+ }+ Ok(Ok(Some((back, front))))+}++/// One side of `smlib_split_body`: a one-face sheet on the tool's surface, turned over with `flip`.+fn side(k: &mut Kernel, body: &Body, spec: &Spec, flip: bool) -> solidcore::Result<Out<Brep>> {+ let tolerance = body.0.lock().unwrap_or_else(PoisonError::into_inner).tolerance();+ let t = match tool(k, spec)? {+ Ok(t) => t,+ Err(e) => return Ok(Err(e)),+ };+ let mut surface = t.surface.copy(k)?;+ if flip && let Err(e) = surface.swap_uv(k) {+ return Ok(Err(status(e)));+ }+ let mut sheet = new_brep(k, USE_DEFAULT, USE_DEFAULT)?;+ sheet.set_tolerance(tolerance);+ let natural = surface.natural_uv_domain_with_nurb(k)?;+ if let Err(e) = build_faces(&mut sheet, |s, fenv| create_face_from_surface(k, s, Some(surface), &natural, fenv)) {+ return Ok(Err(status(e)));+ }+ sheet.refresh_cached_topology();+ Ok(Ok(sheet))+}++/// `smlib_split_body`: the manifold solid `body` cut in two by the tool: the part behind the+/// surface (its normal points away) and the part in front. A side left empty is `None`+/// (`SMLIB_ERR_NO_CUT`); a body that is no manifold solid is [`Error::NotSolid`].+pub(crate) fn split_body(body: &Body, spec: &Spec) -> Result<Option<(Body, Body)>> {+ if body.0.is_poisoned() {+ return Err(Error::Internal("smlib_split_body: the body was left unfinished by an earlier panic".to_owned()));+ }+ let r = run("smlib_split_body", |k| {+ super::dump::input(k, "brep", &body.0.lock().unwrap_or_else(PoisonError::into_inner));+ both_sides(k, body, false, |k, flip| side(k, body, spec, flip))+ })??;+ Ok(r.map(|(b, f)| (Body::new(b), Body::new(f))))+}++/// `smlib_split_body_by_sheet`: the manifold solid `body` cut in two by `sheet` as it is (one or+/// more faces joined edge to edge), its surfaces turned to agree with face `face`'s+/// (`SmBrep::OrientSheetSurfaces`), for the back all turned over: the part behind that normal and+/// the part in front. A sheet that does not divide the body is `None` (`SMLIB_ERR_NO_CUT`). A+/// `sheet` that is no sheet, or a `face` out of range, is [`Error::Argument`].+pub(crate) fn split_body_by_sheet(body: &Body, sheet: &Body, face: usize) -> Result<Option<(Body, Body)>> {+ if std::ptr::eq(body, sheet) {+ return Err(Error::Argument);+ }+ if body.0.is_poisoned() || sheet.0.is_poisoned() {+ return Err(Error::Internal("smlib_split_body_by_sheet: a body was left unfinished by an earlier panic".to_owned()));+ }+ let r = run("smlib_split_body_by_sheet", |k| {+ super::dump::input(k, "brep", &body.0.lock().unwrap_or_else(PoisonError::into_inner));+ {+ let g = sheet.0.lock().unwrap_or_else(PoisonError::into_inner);+ super::dump::input(k, "sheet", &g);+ if !is_sheet(k, &g)? || face >= g.face_list().len() {+ return Ok(Err(Error::Argument));+ }+ }+ both_sides(k, body, true, |k, flip| {+ let mut copy = {+ let g = sheet.0.lock().unwrap_or_else(PoisonError::into_inner);+ brep_copy(k, &g)?+ };+ let Some(&f) = brep_p1::faces(©, None)?.get(face) else { return Ok(Err(Error::Argument)) };+ // The UV swaps notify as SMLib's objects do: through the kernel's callbacks, with+ // the sheet's own attributes, so its faces' tags see each swap.+ let turned = with_kernel_callbacks(k, &mut copy, |k, b, env| orient_sheet_surfaces(k, b, Some(f), !flip, env));+ copy.refresh_cached_topology();+ Ok(match turned {+ Ok(()) => Ok(copy),+ Err(e) => Err(status(e)),+ })+ })+ })??;+ Ok(r.map(|(b, f)| (Body::new(b), Body::new(f))))+}diff --git a/crates/smlib/src/core/split_tests.rs b/crates/smlib/src/core/split_tests.rsnew file mode 100644index 0000000000..f2c5c0de65--- /dev/null+++ b/crates/smlib/src/core/split_tests.rs@@ -0,0 +1,429 @@+//! Split Face and Split Body on solidcore, against closed forms: face, edge and vertex counts,+//! volumes, how many faces each chosen face became, and every result exports to a record that+//! validates. With SMLib built, the same input converted to the C++ kernel and the same tools+//! give the same result or the same error (parity only: the expected values are the analytic+//! ones).+//!+//! The body is a 10 mm cube [0, 10]^3 on solidcore; the tools are described as+//! [`crate::ssi::Surface`] describes them.++use super::split::{split_body, split_body_by_sheet, split_faces};+use super::{Body, area, counts, make_box, to_arrays, volume};+use crate::Error;+use crate::export::native;+use crate::ssi::Spec;++const X: [f64; 3] = [1.0, 0.0, 0.0];+const Y: [f64; 3] = [0.0, 1.0, 0.0];+const Z: [f64; 3] = [0.0, 0.0, 1.0];++fn cube() -> Body {+ make_box([0.0; 3], [10.0; 3]).unwrap()+}++/// The plane x = `at` over u (along y) and v (along z) in `[-1, 11]`: it reaches over the cube.+fn plane_x(at: f64) -> Spec {+ Spec::Plane { origin: [at, 0.0, 0.0], xaxis: Y, yaxis: Z, u: [-1.0, 11.0], v: [-1.0, 11.0] }+}++/// The cylinder of radius 3 about the vertical line through (5, 5), from z = -1 to 11.+fn cylinder() -> Spec {+ Spec::Cylinder { origin: [5.0, 5.0, 0.0], xaxis: X, yaxis: Y, radius: 3.0, angle_deg: [0.0, 360.0], height: [-1.0, 11.0] }+}++#[derive(Clone, Debug)]+enum Op {+ /// Split the faces (all six when empty) by the tools.+ Faces(Vec<usize>, Vec<Spec>),+ Body(Spec),+}++#[derive(Clone, Debug, PartialEq)]+enum Expect {+ /// Volume, counts, and the total of faces made.+ Split(f64, [usize; 3], usize),+ /// The two sides' volumes and counts.+ Halves(f64, [usize; 3], f64, [usize; 3]),+ NoCut,+}++fn case(name: &str) -> (Op, Expect) {+ let all: Vec<usize> = (0..6).collect();+ match name {+ // Four faces cross x = 5, each cut in two; the four edges along x are cut at it.+ "split_faces_by_a_plane" => (Op::Faces(all, vec![plane_x(5.0)]), Expect::Split(1000.0, [10, 20, 12], 4)),+ // The cylinder meets the top and the bottom in a circle each: a disc and a holed face.+ "split_faces_by_a_cylinder" => (Op::Faces(all, vec![cylinder()]), Expect::Split(1000.0, [8, 14, 10], 2)),+ // Two planes in turn, the second cutting the first's pieces.+ "split_faces_by_two_planes" => (Op::Faces(all, vec![plane_x(3.0), plane_x(7.0)]), Expect::Split(1000.0, [14, 28, 16], 8)),+ "split_faces_missed_by_the_tool" => (Op::Faces(all, vec![plane_x(20.0)]), Expect::NoCut),+ "split_body_by_a_plane" => (Op::Body(plane_x(3.0)), Expect::Halves(300.0, [6, 12, 8], 700.0, [6, 12, 8])),+ // A tool that misses leaves both parts the whole body.+ "split_body_missed_by_the_tool" => (Op::Body(plane_x(20.0)), Expect::Halves(1000.0, [6, 12, 8], 1000.0, [6, 12, 8])),+ _ => panic!("no case {name}"),+ }+}++#[derive(Debug, PartialEq)]+enum Measured {+ Split { volume: f64, counts: [usize; 3], made: Vec<usize> },+ Halves { volumes: [f64; 2], counts: [[usize; 3]; 2] },+ NoCut,+}++type Got = std::result::Result<Measured, Error>;++fn rel(a: f64, b: f64) -> f64 {+ (a - b).abs() / b.abs()+}++fn valid(name: &str, b: &Body) {+ let (rec, _) = native(&to_arrays(b).unwrap()).unwrap_or_else(|e| panic!("{name}: record: {e:?}"));+ rec.validate().unwrap_or_else(|e| panic!("{name}: record: {e}"));+}++fn judge(name: &str, who: &str, got: Got) -> Got {+ let (_, expect) = case(name);+ match (&expect, &got) {+ (_, Err(g)) => panic!("{name}: {who} failed: {g}"),+ (Expect::NoCut, Ok(m)) => assert_eq!(*m, Measured::NoCut, "{name}: {who}"),+ (Expect::Split(v, n, total), Ok(Measured::Split { volume, counts, made })) => {+ assert!(rel(*volume, *v) < 1e-9, "{name}: {who} volume {volume} vs analytic {v}");+ assert_eq!(counts, n, "{name}: {who} counts");+ assert_eq!(made.iter().sum::<usize>(), *total, "{name}: {who} faces made {made:?}");+ }+ (Expect::Halves(v0, n0, v1, n1), Ok(Measured::Halves { volumes, counts })) => {+ assert!(rel(volumes[0], *v0) < 1e-9 && rel(volumes[1], *v1) < 1e-9, "{name}: {who} volumes {volumes:?} vs {v0} {v1}");+ assert_eq!(counts, &[*n0, *n1], "{name}: {who} counts");+ }+ (e, Ok(m)) => panic!("{name}: {who} gave {m:?}, expected {e:?}"),+ }+ got+}++fn solidcore_case(name: &str) -> Got {+ let (op, _) = case(name);+ let got = match &op {+ Op::Faces(faces, tools) => {+ let tools: Vec<&Spec> = tools.iter().collect();+ split_faces(&cube(), faces, &tools).map(|r| match r {+ None => Measured::NoCut,+ Some((b, made)) => {+ valid(name, &b);+ Measured::Split { volume: volume(&b, 1e-8).unwrap(), counts: counts(&b).unwrap(), made }+ }+ })+ }+ Op::Body(tool) => split_body(&cube(), tool).map(|r| match r {+ None => Measured::NoCut,+ Some((b, f)) => {+ valid(name, &b);+ valid(name, &f);+ Measured::Halves {+ volumes: [volume(&b, 1e-8).unwrap(), volume(&f, 1e-8).unwrap()],+ counts: [counts(&b).unwrap(), counts(&f).unwrap()],+ }+ }+ }),+ };+ judge(name, "solidcore", got)+}++/// The C++ kernel's surface for `spec`.+#[cfg(feature = "native")]+fn surface(spec: &Spec) -> crate::ssi::Surface {+ use crate::ssi::Surface;+ match spec {+ Spec::Plane { origin, xaxis, yaxis, u, v } => Surface::plane(*origin, *xaxis, *yaxis, *u, *v),+ Spec::Cylinder { origin, xaxis, yaxis, radius, angle_deg, height } => {+ Surface::cylinder(*origin, *xaxis, *yaxis, *radius, *angle_deg, *height)+ }+ _ => panic!("no such tool in these cases"),+ }+ .unwrap()+}++/// The case on the C++ kernel, called directly (whatever the choice), on the cube converted+/// from solidcore's.+#[cfg(feature = "native")]+fn cpp_case(name: &str) -> Got {+ use crate::{Brep, error, ffi};+ crate::init().unwrap();+ let (op, _) = case(name);+ let body = Brep::made_core(cube());+ let measure = |h: &ffi::Handle| {+ let (rec, _) = native(&Brep::made(ffi::copy(h).unwrap()).cpp_arrays().unwrap()).unwrap();+ rec.validate().unwrap();+ (ffi::volume(h, 1e-8).unwrap(), ffi::counts(h).unwrap().map(|x| usize::try_from(x).unwrap()))+ };+ let got = match &op {+ Op::Faces(faces, tools) => {+ let made: Vec<crate::ssi::Surface> = tools.iter().map(surface).collect();+ let handles: Vec<&ffi::ssi::SurfaceHandle> = made.iter().map(|s| s.handle().unwrap()).collect();+ let faces: Vec<i64> = faces.iter().map(|&f| f as i64).collect();+ match ffi::split::split_faces(body.cpp().unwrap(), &faces, &handles) {+ Ok((h, made)) => {+ let (volume, counts) = measure(&h);+ Ok(Measured::Split { volume, counts, made: made.into_iter().map(|m| usize::try_from(m).unwrap()).collect() })+ }+ Err(ffi::ops::ERR_NO_CUT) => Ok(Measured::NoCut),+ Err(s) => Err(error(s)),+ }+ }+ Op::Body(tool) => match ffi::split::split_body(body.cpp().unwrap(), surface(tool).handle().unwrap()) {+ Ok((b, f)) => {+ let (vb, nb) = measure(&b);+ let (vf, nf) = measure(&f);+ Ok(Measured::Halves { volumes: [vb, vf], counts: [nb, nf] })+ }+ Err(ffi::ops::ERR_NO_CUT) => Ok(Measured::NoCut),+ Err(s) => Err(error(s)),+ },+ };+ judge(name, "C++", got)+}++#[cfg(feature = "native")]+fn parity(name: &str) {+ match (solidcore_case(name), cpp_case(name)) {+ (Ok(Measured::Split { volume: a, counts: na, made: ma }), Ok(Measured::Split { volume: b, counts: nb, made: mb })) => {+ assert!(rel(a, b) < 1e-9, "{name}: solidcore {a} vs C++ {b}");+ assert_eq!(na, nb, "{name}: counts (solidcore vs C++)");+ assert_eq!(ma, mb, "{name}: faces made per face (solidcore vs C++)");+ }+ (Ok(Measured::Halves { volumes: a, counts: na }), Ok(Measured::Halves { volumes: b, counts: nb })) => {+ assert!(rel(a[0], b[0]) < 1e-9 && rel(a[1], b[1]) < 1e-9, "{name}: solidcore {a:?} vs C++ {b:?}");+ assert_eq!(na, nb, "{name}: counts (solidcore vs C++)");+ }+ (a, b) => assert_eq!(a, b, "{name}: solidcore vs C++"),+ }+}++macro_rules! cases {+ ($($m:ident $(: $ign:meta)?),* $(,)?) => {$(+ mod $m {+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_closed_form() {+ let _ = super::solidcore_case(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ super::parity(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ fn the_cpp_kernel_matches_the_closed_form() {+ let _cpp = crate::route::on_cpp();+ let _ = super::cpp_case(stringify!($m));+ }+ }+ )*};+}++cases!(+ split_faces_by_a_plane,+ split_faces_by_a_cylinder,+ split_faces_by_two_planes,+ split_faces_missed_by_the_tool,+ split_body_by_a_plane,+ split_body_missed_by_the_tool,+);++/// The capi's argument checks, before any kernel call.+#[test]+fn hostile_arguments_are_refused() {+ let b = cube();+ let p = plane_x(5.0);+ assert_eq!(split_faces(&b, &[], &[&p]).err(), Some(Error::Argument), "no face");+ assert_eq!(split_faces(&b, &[0], &[]).err(), Some(Error::Argument), "no tool");+ assert_eq!(split_faces(&b, &[0, 0], &[&p]).err(), Some(Error::Argument), "a face twice");+ assert_eq!(split_faces(&b, &[6], &[&p]).err(), Some(Error::Argument), "no face 6");+ assert_eq!(split_faces(&b, &[usize::MAX], &[&p]).err(), Some(Error::Argument), "no face usize::MAX");+ let many = vec![&p; super::split::MAX_TOOLS + 1];+ assert_eq!(split_faces(&b, &[0], &many).err(), Some(Error::Argument), "too many tools");+ let faces: Vec<usize> = (0..=super::split::MAX_FACES).collect();+ assert_eq!(split_faces(&b, &faces, &[&p]).err(), Some(Error::Argument), "too many faces");+}++/// A sheet is no solid to split in two (`SMLIB_ERR_NOT_SOLID`).+#[test]+fn a_sheet_is_not_split_into_two_bodies() {+ use solidcore::curve::curve::Curve;+ use solidcore::geom::vector3d::Vec3;+ use solidcore::primitive::api_curves::create_line_segment;+ use solidcore::sweep::api_brep::create_linear_sweep;+ let sheet = super::run("sheet", |k| {+ let c = Curve::from(create_line_segment(Vec3::new(0.0, 0.0, 0.0), Vec3::new(10.0, 0.0, 0.0))?);+ create_linear_sweep(k, &[Some(&c)], Vec3::new(0.0, 1.0, 0.0), 10.0, false)+ })+ .map(Body::new)+ .unwrap();+ assert!(rel(area(&sheet, 1e-8).unwrap(), 100.0) < 1e-9);+ assert_eq!(split_body(&sheet, &plane_x(5.0)).err(), Some(Error::NotSolid));+}++/// Faces of the box -20..5 x -20..20 x -20..5 copied off it into a sheet (`CopyFaces` with merge,+/// as the capi's test): the top z = 5 and, with `side`, the side x = 5 too.+fn lid(side: bool) -> Body {+ use solidcore::EntityRef;+ use solidcore::geom::tol::USE_DEFAULT;+ use solidcore::query::api_queries::face_internal_point;+ use solidcore::topology::brep::p1::faces;+ use solidcore::topology::brep::p2::ArenaNotifyState;+ use solidcore::topology::brep::p3::new_brep;+ use solidcore::topology::brep::p7::copy_faces;+ let slab = make_box([-20.0; 3], [25.0, 40.0, 25.0]).unwrap();+ super::run("sheet", |k| {+ let mut whole = solidcore::topology::brep::p3::brep_copy(k, &slab.0.lock().unwrap())?;+ let mut picked = Vec::new();+ for f in faces(&whole, None)? {+ let p = face_internal_point(k, &mut whole, f)?;+ if (p.z - 5.0).abs() < 1e-9 || (side && (p.x - 5.0).abs() < 1e-9) {+ picked.push(f);+ }+ }+ assert_eq!(picked.len(), if side { 2 } else { 1 });+ let mut w = new_brep(k, USE_DEFAULT, USE_DEFAULT)?;+ w.set_tolerance(whole.tolerance());+ {+ let mut state = ArenaNotifyState::new(&w);+ let mut env = state.env(None);+ let key_of = env.key_of;+ let this_face = |f| key_of(EntityRef::Face(f));+ copy_faces(k, &mut whole, &picked, &mut w, true, &this_face, &mut env)?;+ }+ w.refresh_cached_topology();+ Ok(w)+ })+ .map(Body::new)+ .unwrap()+}++/// The capi's test of `smlib_split_body_by_sheet` (fork 2fc375f): a cube 0..10 cut by an L of two+/// faces: the corner x < 5, z < 5 (250) on one side, the rest (750) on the other, whichever face+/// the sides are read from; on C++ too.+#[test]+fn split_body_by_an_l_sheet() {+ #[cfg(feature = "native")]+ let _cpp = crate::route::on_cpp();+ let (c, sheet) = (cube(), lid(true));+ for face in 0..2 {+ let (b, f) = split_body_by_sheet(&c, &sheet, face).unwrap().expect("the sheet divides the cube");+ valid("L sheet", &b);+ valid("L sheet", &f);+ let (vb, vf) = (volume(&b, 1e-8).unwrap(), volume(&f, 1e-8).unwrap());+ assert!(rel(vb.min(vf), 250.0) < 1e-9 && rel(vb.max(vf), 750.0) < 1e-9, "face {face}: {vb} + {vf}");+ #[cfg(feature = "native")]+ {+ let (body, tool) = (crate::Brep::made_core(cube()), crate::Brep::made_core(lid(true)));+ let (bc, fc) = crate::ffi::split::split_body_by_sheet(body.cpp().unwrap(), tool.cpp().unwrap(), face as i64).unwrap();+ let (vbc, vfc) = (crate::ffi::volume(&bc, 1e-8).unwrap(), crate::ffi::volume(&fc, 1e-8).unwrap());+ assert!(rel(vb, vbc) < 1e-9 && rel(vf, vfc) < 1e-9, "face {face}: {vb} + {vf} vs C++ {vbc} + {vfc}");+ }+ }+}++/// What `smlib_split_body_by_sheet` refuses: a body that is no sheet, a face out of range, the+/// sheet as its own body; a face that ends inside the cube only nicks it, which is no cut.+#[test]+fn split_by_a_sheet_refuses() {+ let (c, sheet) = (cube(), lid(true));+ assert_eq!(split_body_by_sheet(&c, &make_box([-20.0; 3], [25.0, 40.0, 25.0]).unwrap(), 0).err(), Some(Error::Argument));+ assert_eq!(split_body_by_sheet(&c, &sheet, 2).err(), Some(Error::Argument));+ assert_eq!(split_body_by_sheet(&c, &c, 0).err(), Some(Error::Argument));+ assert!(split_body_by_sheet(&c, &lid(false), 0).unwrap().is_none());+ assert_eq!(split_body_by_sheet(&sheet, &lid(false), 0).err(), Some(Error::NotSolid));+}++/// The body split is never changed.+#[test]+fn the_body_stays_as_it_was() {+ let b = cube();+ let _ = split_faces(&b, &[0, 1, 2, 3, 4, 5], &[&plane_x(5.0)]).unwrap();+ let _ = split_body(&b, &plane_x(5.0)).unwrap();+ assert_eq!(counts(&b).unwrap(), [6, 12, 8]);+ assert!(rel(volume(&b, 1e-8).unwrap(), 1000.0) < 1e-12);+}++/// Face and edge tags (`Brep::tagged`) through a face split on solidcore, as on C++.+#[cfg(feature = "native")]+mod history {+ use crate::{Brep, ffi};++ #[test]+ fn tags_cross_a_face_split() {+ let _cpp = crate::route::on_cpp();+ crate::init().unwrap();+ let a = Brep::made_core(super::cube()).tagged(0).unwrap();+ let p = super::plane_x(5.0);+ let s = super::surface(&p);+ let faces = [0i64, 1, 2, 3, 4, 5];+ let cpp = Brep::made(ffi::split::split_faces(a.cpp().unwrap(), &faces, &[s.handle().unwrap()]).unwrap().0).history().unwrap();+ let core = super::split_faces(a.core().unwrap(), &[0, 1, 2, 3, 4, 5], &[&p]).unwrap().unwrap().0;+ let core = Brep::made_core(core).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ }+}++/// A one-face sheet on a B-spline surface (as SolidCraft's extrude of a sketch spline makes it:+/// the cubic through (0, 0), (13, -8), (27, 8), (40, 0) in x and z, straight along y over+/// [0, 40]) cut by four plane strips standing on the square [12, 28]^2: the strips meet the+/// face inside its bounds, so the face's surface is intersected through its face's trimmed+/// cache. The square comes out as a face of its own, the sheet holed by it.+#[test]+fn a_spline_sheet_is_cut_by_strips_inside_it() {+ use solidcore::geom::tol::USE_DEFAULT;+ use solidcore::geom::vector3d::Vec3;+ use solidcore::nurbs::b_spline_curve::p1::KnotType;+ use solidcore::nurbs::b_spline_surface::p1::{BSplineSurface, BSplineSurfaceForm, CanonicalSurfaceData};+ use solidcore::surface::surface::Surface;+ use solidcore::topology::brep::p3::new_brep;+ use solidcore::topology::brep::p8::create_face_from_surface;+ // Control points u-major: the curve's four, each at y = 0 and y = 40.+ let curve = [[0.0, 0.0], [13.0, -8.0], [27.0, 8.0], [40.0, 0.0]];+ let pts: Vec<Vec3> = curve.iter().flat_map(|[x, z]| [Vec3::new(*x, 0.0, *z), Vec3::new(*x, 40.0, *z)]).collect();+ let sheet = super::run("sheet", |k| {+ let surface = Surface::from(BSplineSurface::create_canonical(&CanonicalSurfaceData {+ u_degree: 3,+ v_degree: 1,+ control_points: &pts,+ form: BSplineSurfaceForm::Unspecified,+ u_multiplicities: &[4, 4],+ v_multiplicities: &[2, 2],+ u_knots: &[0.0, 1.0],+ v_knots: &[0.0, 40.0],+ knot_type: KnotType::Unspecified,+ weights: None,+ uv_domain: None,+ })?);+ let mut b = new_brep(k, USE_DEFAULT, USE_DEFAULT)?;+ let natural = surface.natural_uv_domain_with_nurb(k)?;+ super::sweep::build_faces(&mut b, |s, fenv| create_face_from_surface(k, s, Some(surface), &natural, fenv))?;+ b.refresh_cached_topology();+ Ok(b)+ })+ .map(Body::new)+ .unwrap();+ assert_eq!(counts(&sheet).unwrap(), [1, 4, 4]);+ let whole = area(&sheet, 1e-8).unwrap();+ // The strip standing on the line from `o` along `d` (16 long), reaching past the sheet in z.+ let strip = |o: [f64; 3], d: [f64; 3]| Spec::Plane { origin: o, xaxis: Z, yaxis: d, u: [-60.0, 60.0], v: [0.0, 16.0] };+ let tools = [+ strip([12.0, 12.0, 0.0], X),+ strip([28.0, 12.0, 0.0], Y),+ strip([28.0, 28.0, 0.0], [-1.0, 0.0, 0.0]),+ strip([12.0, 28.0, 0.0], [0.0, -1.0, 0.0]),+ ];+ let tools: Vec<&Spec> = tools.iter().collect();+ let (cut, made) = split_faces(&sheet, &[0], &tools).unwrap().expect("the strips cut the sheet");+ valid("spline sheet", &cut);+ // The square's face and the holed sheet: four edges and vertices round each.+ assert_eq!(counts(&cut).unwrap(), [2, 8, 8]);+ assert_eq!(made, [1]);+ // Cutting moves no surface: the pieces cover the sheet.+ assert!(rel(area(&cut, 1e-8).unwrap(), whole) < 1e-9);+}diff --git a/crates/smlib/src/core/ssi.rs b/crates/smlib/src/core/ssi.rsnew file mode 100644index 0000000000..f24b3f95f6--- /dev/null+++ b/crates/smlib/src/core/ssi.rs@@ -0,0 +1,121 @@+//! Surface/surface intersection on solidcore (`smlib_ssi.cpp`'s `smlib_ssi`, `smlib_surface_domain`,+//! `smlib_surface_evaluate`), on the surfaces [`crate::core::split`] makes from a [`Spec`]:+//! `SmSurface::GlobalSurfaceIntersect` and `SmAdvSurfaceIntersector`, whose results are read as the+//! capi reads them.++use std::borrow::Cow;++use solidcore::curve::curve::Curve;+use solidcore::geom::vector2d::Point2;+use solidcore::intersect::surface_intersector::p5::do_intersection;+use solidcore::kernel::Kernel;+use solidcore::nurbs::b_spline_curve::BSplineCurve;+use solidcore::surface::surface::p2::{SurfaceIntersection, TsectCurveType};++use super::convert::bspline_curve_part;+use super::run;+use super::split::{Tool, tool};+use crate::ffi::ssi::Nurbs;+use crate::ssi::{CurveType, Method, Spec, SsiCurve, SsiPoint, SsiResult, curve2, curve3};+use crate::{Error, Result};++/// The surface of `spec` with its natural UV domain (`construct`).+pub(crate) fn surface(spec: &Spec) -> Result<Tool> {+ run("smlib_surface", |k| tool(k, spec))?+}++/// `[u0, u1, v0, v1]`.+pub(crate) fn domain(s: &Tool) -> [f64; 4] {+ let (lo, hi) = (s.domain.min(), s.domain.max());+ [lo.x, hi.x, lo.y, hi.y]+}++/// The surface's point at (u, v): `smlib_surface_evaluate`, a non-finite point being `SM_ERR`.+pub(crate) fn evaluate(s: &Tool, u: f64, v: f64) -> Result<[f64; 3]> {+ if !u.is_finite() || !v.is_finite() {+ return Err(Error::Argument);+ }+ let p = run("smlib_surface_evaluate", |k| s.surface.evaluate_point(k, Point2::new(u, v)))?;+ let r = [p.x, p.y, p.z];+ if r.iter().all(|x| x.is_finite()) { Ok(r) } else { Err(Error::Solidcore("smlib_surface_evaluate: not a finite point".into())) }+}++fn curve_type(t: TsectCurveType) -> CurveType {+ match t {+ TsectCurveType::Unknown => CurveType::Unknown,+ TsectCurveType::Touching => CurveType::Touching,+ TsectCurveType::Crossing => CurveType::Crossing,+ TsectCurveType::Tangent => CurveType::Tangent,+ TsectCurveType::Coincident => CurveType::Coincident,+ TsectCurveType::NearTangent => CurveType::NearTangent,+ TsectCurveType::RegionBoundary => CurveType::RegionBoundary,+ }+}++/// The capi's `nurbs`: `c` as its B-spline, control points made cartesian in `dim` coordinates;+/// `None` for a curve that is not one, which is never approximated here.+fn nurbs(k: &Kernel, c: &Curve, dim: usize) -> Result<Option<Nurbs>> {+ let Some(part): Option<Cow<'_, BSplineCurve>> = bspline_curve_part(k, c)? else { return Ok(None) };+ let Some(n) = part.gw_nurb() else { return Ok(None) };+ let mut out = Nurbs { points: Vec::with_capacity(n.cpts().len() * dim), weights: Vec::with_capacity(n.cpts().len()), knots: n.knots().to_vec() };+ for p in n.cpts() {+ let w = if p.w != solidcore::nurbs::math::NOW { p.w } else { 1.0 };+ let q = [p.x / w, p.y / w, p.z / w];+ out.points.extend_from_slice(q.get(..dim).unwrap_or(&q));+ out.weights.push(w);+ }+ Ok(Some(out))+}++/// The capi's `start`: where `c` starts, NaN where there is no curve or it can't be evaluated.+fn start(k: &Kernel, c: Option<&Curve>) -> [f64; 3] {+ c.and_then(|c| c.evaluate_point(k, c.natural_interval().min()).ok()).map_or([f64::NAN; 3], |p| [p.x, p.y, p.z])+}++fn read(k: &Kernel, r: &SurfaceIntersection) -> Result<SsiResult> {+ let mut out = SsiResult::default();+ for (i, c3) in r.curves_3d.iter().enumerate() {+ let (ua, ub) = (r.surface1_uv_curves.get(i).and_then(Option::as_ref), r.surface2_uv_curves.get(i).and_then(Option::as_ref));+ let ty = r.curve_types.get(i).copied();+ let ivl = c3.natural_interval();+ let uv = |c: Option<&Curve>| -> Result<_> { Ok(c.map(|c| nurbs(k, c, 2)).transpose()?.flatten().map(curve2)) };+ out.curves.push(SsiCurve {+ curve_type: ty.map_or(CurveType::None, curve_type),+ deviation: r.deviations.get(i).copied().unwrap_or(f64::NAN),+ interval: [ivl.min(), ivl.max()],+ // A curve that is no B-spline is the one thing the result can't hold.+ curve: curve3(nurbs(k, c3, 3)?.ok_or(Error::Unsupported)?),+ uv_a: uv(ua)?,+ uv_b: uv(ub)?,+ });+ if ty == Some(TsectCurveType::Touching) {+ let (a, b) = (start(k, ua), start(k, ub));+ out.points.push(SsiPoint { xyz: start(k, Some(c3)), uv_a: [a[0], a[1]], uv_b: [b[0], b[1]] });+ }+ }+ Ok(out)+}++/// `smlib_ssi`: `a` and `b` within their domains, at approximation tolerance `approx_tol` (<= 0:+/// the kernel's default).+pub(crate) fn intersect(a: &Tool, b: &Tool, method: Method, approx_tol: f64) -> Result<SsiResult> {+ if !approx_tol.is_finite() {+ return Err(Error::Argument);+ }+ let tol = (approx_tol > 0.0).then_some(approx_tol);+ let edges = [true, true];+ run("smlib_ssi", |k| {+ let found = match method {+ Method::Global => a.surface.global_surface_intersect(k, &a.domain, &b.surface, &b.domain, edges, tol, None),+ Method::Advanced => do_intersection(k, &a.surface, &a.domain, &b.surface, &b.domain, edges, tol, None),+ };+ // An SMLib status is an answer, as the C API returns it.+ match found {+ Ok(found) => Ok(read(k, &found)),+ Err(e) => match e.sm_status() {+ Some(status) => Ok(Err(Error::Status(status))),+ None => Err(e),+ },+ }+ })?+}diff --git a/crates/smlib/src/core/sweep.rs b/crates/smlib/src/core/sweep.rsnew file mode 100644index 0000000000..4f02388baf--- /dev/null+++ b/crates/smlib/src/core/sweep.rs@@ -0,0 +1,1726 @@+//! Extrusions, revolutions, sweeps, lofts and planar faces on solidcore: the C API's logic round+//! SM_API's sweeps, ported from the fork's `capi/src/smlib_sweeps.cpp` (`coord_ok`, `unit`,+//! `line`, `arc`, `nurbs`, `parse`, `finish`, `one_loop`, `FlatArc`, `one_circle`, `angle_on`,+//! `one_wall_per_circle`, `straight`, `circular`, `joined`,+//! `put_motion`, `turned`, `Rigid`, `Segment`, `segmented`, `carried`, `piecewise`, `maps_ok`, `placed`, `put_curve`, and the entry points+//! `smlib_planar_faces`, `smlib_extrude`, `smlib_revolve`, `smlib_sweep_placed`, `smlib_loft`,+//! `smlib_loft_to_point`, `smlib_sweep_stations`, `smlib_project_curves`, `smlib_face_section`,+//! and `smlib_screw_sweep` and `smlib_screw_sweep_radial` with `Screw`, `Stations`,+//! `lift_error`, `offset_error`, `path`, `path_curve`, `axial_radius`, `cylinder_piece`,+//! `screw_wall` and `screw_sweep`).+//!+//! As there, each call builds its own curves from the curve list, checks its numbers before the+//! kernel sees them, runs SM_API's sweep and hands the result over only when it is what was asked+//! for: a closed manifold solid when the ends are capped ([`Error::NotSolid`] otherwise), never a+//! body without faces ([`Error::Empty`]).+//!+//! The screw sweeps are the capi's own: it builds their walls from SMLib's B-spline surfaces,+//! cylinders and face builders (`Stations`, `screw_wall`, `cylinder_piece`), with no SM_API+//! sweep behind them, and solidcore leaves them to the capi (solidcore PR #1326, closed as+//! fork-only; #1162 and #1163 triaged not applicable). So they are ported here.++use std::f64::consts::{PI, TAU};++use solidcore::curve::curve::p3::compute_crvs_normal;+use solidcore::curve::curve::{Curve, CurveKind};+use solidcore::curve::ellipse::Ellipse;+use solidcore::curve::line::Line;+use solidcore::geom::axis2_placement::Axis2Placement;+use solidcore::geom::extent1d::Extent1d;+use solidcore::geom::tol::{SmallTopoType, USE_DEFAULT, context_zone_tol_3d};+use solidcore::geom::vector3d::{Point3, Vec3};+use solidcore::heal::stitch::p1::api_stitch_into_solid;+use solidcore::kernel::Kernel;+use solidcore::nurbs::b_spline_curve::{BSplineCurve, BSplineCurveForm, CanonicalData, CurveCanonical, KnotType};+use solidcore::nurbs::b_spline_surface::{BSplineSurface, BSplineSurfaceForm, CanonicalSurfaceData};+use solidcore::nurbs::b_spline_surface_n_lib::p2::OrientType;+use solidcore::primitive::primitive_creation::SweepOptions;+use solidcore::surface::cone::Cone;+use solidcore::surface::surface::Surface;+use solidcore::sweep::api_brep::{+ CornerRefusal, OffsetCornerType, TaperCornerRefusal, TaperExtrude, create_curve_sweep_with_placements, create_linear_sweep,+ create_rotational_sweep, create_taper_extrude_with_corner,+};+use solidcore::sweep::api_surfaces::create_skin_primitive;+use solidcore::topology::brep::p1 as brep_p1;+use solidcore::topology::brep::p1::{ParallelProjectionOptions, create_parallel_projection_curves};+use solidcore::topology::brep::p2::{ArenaNotifyState, is_manifold_solid};+use solidcore::topology::brep::p3::new_brep;+use solidcore::topology::brep::p4::stitch_faces;+use solidcore::topology::brep::p5::{StitchAndOrientOptions, stitch_and_orient};+use solidcore::topology::brep::p7::copy_faces;+use solidcore::topology::brep::p8::{+ FaceBuildEnv, create_face_from_surface, create_faces_with_curves, create_planar_face_with_3d_curves, create_planar_faces_with_3d_curves,+};+use solidcore::topology::brep::planar_section::{PlanarSectionOptions, SectionOutputs, create_planar_section_curves};+use solidcore::topology::topology_traverser::Marks;+use solidcore::topology::{Brep, FaceId};+use solidcore::{EntityRef, SolidError};++use super::blend::status;+use super::offset::{face_miss, pick_faces};+use super::{Body, run, with_body};+use crate::sweeps::{Affine, Curve as Profile, DraftCorner, Ends, MAX_CURVES, MAX_STATION_CURVES, MAX_STATIONS, SweepFrame};+use crate::{Error, Result, ffi};++/// The capi's statuses as SolidCraft errors: an operation's own result.+type Out<T> = std::result::Result<T, Error>;++/// A coordinate no larger than this (mm, 1000 km), so that SMLib's tolerances stay meaningful.+const MAX_COORD: f64 = 1e9;++/// `SMLIB_FLAT_MAX_LEN`: most reals a curve list may hold.+const FLAT_MAX_LEN: usize = 1 << 27;++/// `SMLIB_SCREW_MAX_TURNS`.+const SCREW_MAX_TURNS: f64 = 200.0;++/// `SMLIB_SCREW_MAX_LAW`.+const SCREW_MAX_LAW: usize = 1024;++/// `coord_ok`.+fn coord_ok(p: &[f64]) -> bool {+ p.iter().all(|x| x.is_finite() && x.abs() <= MAX_COORD)+}++fn v3(p: [f64; 3]) -> Vec3 {+ Vec3::new(p[0], p[1], p[2])+}++/// `unit`: a unit vector from `v`, or `None` when it has no usable length.+fn unit(v: [f64; 3]) -> Option<Vec3> {+ if !v.iter().all(|x| x.is_finite()) {+ return None;+ }+ let u = v3(v);+ let n = u.length();+ (n > 1e-12 && n.is_finite()).then(|| u * (1.0 / n))+}++/// An SMLib call's own status passed on (`status(...)` in the capi), else the value.+fn called<T>(r: solidcore::Result<T>) -> Out<T> {+ r.map_err(status)+}++/// `line`.+fn line(start: [f64; 3], end: [f64; 3]) -> Out<Curve> {+ if !coord_ok(&start) || !coord_ok(&end) {+ return Err(Error::Argument);+ }+ let (a, b) = (v3(start), v3(end));+ if !((b - a).length() > 1e-9) {+ return Err(Error::Argument);+ }+ called(Line::create_line_segment(3, a, b, None)).map(Curve::from)+}++/// `arc`: centre, unit axis, unit reference direction (square to the axis), radius, start and+/// end angles (radians, counter-clockwise about the axis from the reference).+fn arc(k: &Kernel, center: [f64; 3], axis: [f64; 3], reference: [f64; 3], radius: f64, start: f64, end: f64) -> Out<Curve> {+ if !coord_ok(¢er) || ![radius, start, end].iter().all(|x| x.is_finite()) {+ return Err(Error::Argument);+ }+ let (Some(axis), Some(r)) = (unit(axis), unit(reference)) else { return Err(Error::Argument) };+ if axis.dot(r).abs() > 1e-9 {+ return Err(Error::Argument);+ }+ let sweep = end - start;+ if !(radius > 1e-9 && radius < MAX_COORD) || start.abs() > 1e6 || !(sweep > 1e-9 && sweep <= TAU * (1.0 + 1e-12)) {+ return Err(Error::Argument);+ }+ // The circle's own parameter starts at the arc's start: SMLib takes intervals in degrees+ // within [-360, 360].+ let y = axis.cross(r);+ let x0 = r * start.cos() + y * start.sin();+ let y0 = axis.cross(x0);+ let frame = Axis2Placement::new(v3(center), x0, y0);+ let degrees = Extent1d::from_min_max(0.0, (sweep * 180.0 / PI).min(360.0));+ called(Ellipse::create_canonical_circle(k, &frame, radius, Some(°rees), None)).map(Curve::from)+}++/// `nurbs`: control points (x, y, z, weight), then points + degree + 1 knots, clamped (end+/// multiplicity degree + 1, inner ones at most degree), non-decreasing.+fn nurbs(degree: usize, points: &[[f64; 4]], knots: &[f64]) -> Out<Curve> {+ let count = points.len();+ if !(1..=ffi::sweeps::CURVE_MAX_DEGREE).contains(°ree) || count < degree + 1 || count > ffi::sweeps::CURVE_MAX_POINTS {+ return Err(Error::Argument);+ }+ let mut ps = Vec::with_capacity(count);+ let mut weights = Vec::with_capacity(count);+ let mut rational = false;+ for p in points {+ if !coord_ok(&p[..3]) || !p[3].is_finite() || !(p[3] > 1e-12 && p[3] < 1e12) {+ return Err(Error::Argument);+ }+ ps.push(Vec3::new(p[0], p[1], p[2]));+ weights.push(p[3]);+ rational = rational || p[3] != 1.0;+ }+ if knots.len() != count + degree + 1 || !knots.iter().all(|x| x.is_finite()) {+ return Err(Error::Argument);+ }+ let (mut unique, mut mult): (Vec<f64>, Vec<usize>) = (Vec::new(), Vec::new());+ for (i, &u) in knots.iter().enumerate() {+ match (i.checked_sub(1).and_then(|j| knots.get(j)), mult.last_mut()) {+ (Some(&prev), _) if u < prev => return Err(Error::Argument),+ (Some(&prev), Some(m)) if u == prev => *m += 1,+ _ => {+ unique.push(u);+ mult.push(1);+ }+ }+ }+ let (Some(&first), Some(&last), Some(&m0), Some(&m1)) = (unique.first(), unique.last(), mult.first(), mult.last()) else {+ return Err(Error::Argument);+ };+ if unique.len() < 2 || m0 != degree + 1 || m1 != degree + 1 || !(last - first > 1e-12) {+ return Err(Error::Argument);+ }+ if mult.iter().skip(1).take(mult.len() - 2).any(|&m| m > degree) {+ return Err(Error::Argument);+ }+ let data = CanonicalData {+ dim: 3,+ degree,+ control_points: &ps,+ form: BSplineCurveForm::Unspecified,+ knot_multiplicities: &mult,+ knots: &unique,+ knot_type: KnotType::Unspecified,+ weights: rational.then_some(weights.as_slice()),+ trim: None,+ };+ called(BSplineCurve::create_canonical(&data)).map(Curve::from)+}++/// `parse`: the curves of a curve list. A list of none, more than [`MAX_CURVES`] or more reals+/// than `SMLIB_FLAT_MAX_LEN` is [`Error::Argument`].+fn parse(k: &Kernel, curves: &[Profile]) -> Out<Vec<Curve>> {+ if curves.is_empty() || curves.len() > MAX_CURVES {+ return Err(Error::Argument);+ }+ let mut reals = 0usize;+ let mut out = Vec::with_capacity(curves.len());+ for c in curves {+ let made = match c {+ Profile::Line { start, end } => {+ reals += 6;+ line(*start, *end)?+ }+ Profile::Arc { center, axis, reference, radius, start, end } => {+ reals += 12;+ arc(k, *center, *axis, *reference, *radius, *start, *end)?+ }+ Profile::Nurbs { degree, points, knots } => {+ // `parse` reads the kinds first: at least two points.+ if *degree < 1 || *degree > ffi::sweeps::CURVE_MAX_DEGREE || points.len() < 2 || points.len() > ffi::sweeps::CURVE_MAX_POINTS {+ return Err(Error::Argument);+ }+ reals = reals.saturating_add(4 * points.len() + points.len() + degree + 1);+ if reals > FLAT_MAX_LEN || knots.len() != points.len() + degree + 1 {+ return Err(Error::Argument);+ }+ nurbs(*degree, points, knots)?+ }+ };+ if reals > FLAT_MAX_LEN {+ return Err(Error::Argument);+ }+ out.push(made);+ }+ Ok(out)+}++/// `finish`: the result must have faces, and be a closed manifold solid when `solid`.+fn finish(b: Brep, solid: bool) -> solidcore::Result<Out<Brep>> {+ if b.face_list().is_empty() {+ return Ok(Err(Error::Empty));+ }+ if solid && !is_manifold_solid(&b)? {+ return Ok(Err(Error::NotSolid));+ }+ Ok(Ok(b))+}++/// Both ends of `c` (`GetEnds`).+fn ends(k: &Kernel, c: &Curve) -> solidcore::Result<(Point3, Point3)> {+ let e = c.ends(k)?;+ Ok((e.start, e.end))+}++/// `one_loop`: whether the curves, in order, run end to end round one closed loop (within `tol`).+fn one_loop(k: &Kernel, curves: &[Curve], tol: f64) -> solidcore::Result<bool> {+ let (mut first, mut prev) = (None, None);+ for c in curves {+ let (a, b) = ends(k, c)?;+ match prev {+ None => first = Some(a),+ Some(p) if (a - p).length() > tol => return Ok(false),+ Some(_) => {}+ }+ prev = Some(b);+ }+ Ok(matches!((first, prev), (Some(f), Some(p)) if (p - f).length() <= tol))+}++/// `FlatArc`: an arc of a curve list as numbers, its frame, radius and angles.+#[derive(Clone, Copy)]+struct FlatArc {+ centre: Vec3,+ axis: Vec3,+ reference: Vec3,+ radius: f64,+ start: f64,+ sweep: f64,+}++impl FlatArc {+ /// `flat_arc`: the arc's numbers, its axis and reference made unit (`parse` has checked+ /// that they can be); `None` for a curve that is no arc.+ fn of(c: &Profile) -> Option<FlatArc> {+ let Profile::Arc { center, axis, reference, radius, start, end } = c else { return None };+ Some(FlatArc {+ centre: v3(*center),+ axis: unit(*axis).unwrap_or_else(|| v3(*axis)),+ reference: unit(*reference).unwrap_or_else(|| v3(*reference)),+ radius: *radius,+ start: *start,+ sweep: end - start,+ })+ }++ /// The point at angle `t` (radians from the reference, counter-clockwise about the axis).+ fn at(&self, t: f64) -> Point3 {+ let y = self.axis.cross(self.reference);+ self.centre + self.reference * (self.radius * t.cos()) + y * (self.radius * t.sin())+ }++ /// `angle_on`: the angle of `p` on this arc's circle, in its frame (radians, in [0, 2π)).+ fn angle_on(&self, p: Point3) -> f64 {+ let d = p - self.centre;+ let y = self.axis.cross(self.reference);+ let t = d.dot(y).atan2(d.dot(self.reference));+ if t < 0.0 { t + TAU } else { t }+ }+}++/// `one_circle`: whether arcs `a` and `b` lie on one circle to `tol`: centres and radii within+/// it, and the axes alike (the same way round) to within it at the rim.+fn one_circle(a: &FlatArc, b: &FlatArc, tol: f64) -> bool {+ (a.centre - b.centre).length() <= tol+ && (a.radius - b.radius).abs() <= tol+ && a.axis.dot(b.axis) > 0.0+ && a.axis.cross(b.axis).length() * a.radius.max(b.radius) <= tol+}++/// `one_wall_per_circle` (tangency-labs/smlib 7dee48f): the profile `curves` (parsed from+/// `given`) with each run of consecutive arcs on one circle within a loop made one arc, so that+/// the run's wall is one face as a single arc's is: a circle drawn in pieces (split where another+/// sketch curve ends on it) sweeps the one cylinder it lies on, not a face per piece meeting the+/// next along a line that is no edge of the shape. A run that is its whole loop is the full+/// circle, swept as a plain circle is: one periodic face, its seam the one edge it uses twice.+/// The seam goes where a plain circle has it: when the arcs are pieces of one drawn circle (they+/// share its frame, the reference direction their angles are measured from), at that circle's+/// own start, angle 0 of that frame; otherwise at the middle of the run's longest arc (the first+/// of equal ones, in profile order). `tol` is the model's zone tolerance, within which+/// consecutive curves already meet.+fn one_wall_per_circle(k: &Kernel, given: &[Profile], curves: Vec<Curve>, tol: f64) -> solidcore::Result<Out<Vec<Curve>>> {+ let n = curves.len();+ if given.len() != n {+ return Ok(Err(Error::Argument));+ }+ let arcs: Vec<Option<FlatArc>> = given.iter().map(FlatArc::of).collect();+ let (mut head, mut tail) = (Vec::with_capacity(n), Vec::with_capacity(n));+ for c in &curves {+ let (a, b) = ends(k, c)?;+ head.push(a);+ tail.push(b);+ }+ // Whether the end of curve `i` meets the start of curve `j`; whether arc `j` goes on from+ // arc `i`, on its circle.+ let meets = |i: usize, j: usize| matches!((tail.get(i), head.get(j)), (Some(t), Some(h)) if (*t - *h).length() <= tol);+ let arc_of = |i: usize| arcs.get(i).copied().flatten();+ let joins = |i: usize, j: usize| match (arc_of(i), arc_of(j)) {+ (Some(a), Some(b)) => meets(i, j) && one_circle(&a, &b, tol),+ _ => false,+ };+ let mut taken: Vec<Option<Curve>> = curves.into_iter().map(Some).collect();+ let mut take = |i: usize| taken.get_mut(i).and_then(Option::take).ok_or(Error::Argument);+ let mut out = Vec::with_capacity(n);+ let mut first = 0;+ while first < n {+ // The loop from `first`: its curves run end to end until one ends at its start.+ let mut last = first;+ while last + 1 < n && !meets(last, first) && meets(last, last + 1) {+ last += 1;+ }+ let len = last - first + 1;+ let closed = meets(last, first);+ // Whether two of the loop's arcs go on on one circle.+ let mut any = false;+ let mut j = 0;+ while j + 1 < len || (closed && len > 1 && j < len) {+ any = any || joins(first + j, first + (j + 1) % len);+ j += 1;+ }+ if !any {+ for i in first..=last {+ match take(i) {+ Ok(c) => out.push(c),+ Err(e) => return Ok(Err(e)),+ }+ }+ first = last + 1;+ continue;+ }+ // A run starts where its curve does not go on from the one before it round the loop.+ let mut begin = 0;+ if closed {+ while begin < len && joins(first + (begin + len - 1) % len, first + begin) {+ begin += 1;+ }+ }+ if begin == len {+ // The whole loop is arcs of one circle: the full circle, its seam at the drawn+ // circle's start when the arcs share its frame, else at the middle of the longest arc.+ let Some(a) = arc_of(first) else { return Ok(Err(Error::Argument)) };+ let mut one_frame = true;+ let mut longest = a;+ for i in first..=last {+ let Some(b) = arc_of(i) else { return Ok(Err(Error::Argument)) };+ one_frame = one_frame && (b.reference - a.reference).length() * a.radius <= tol;+ if b.sweep > longest.sweep {+ longest = b;+ }+ }+ let seam = if one_frame { 0.0 } else { a.angle_on(longest.at(longest.start + 0.5 * longest.sweep)) };+ let p = |v: Vec3| [v.x, v.y, v.z];+ match arc(k, p(a.centre), p(a.axis), p(a.reference), a.radius, seam, seam + TAU) {+ Ok(c) => out.push(c),+ Err(e) => return Ok(Err(e)),+ }+ } else {+ let mut kk = 0;+ while kk < len {+ let i = first + (begin + kk) % len;+ // The arcs i, i + 1, ... round the loop that go on on its circle.+ let mut m = 1;+ while kk + m < len && joins(first + (begin + kk + m - 1) % len, first + (begin + kk + m) % len) {+ m += 1;+ }+ if m == 1 {+ match take(i) {+ Ok(c) => out.push(c),+ Err(e) => return Ok(Err(e)),+ }+ } else {+ let (Some(a), Some(&h)) = (arc_of(i), head.get(i)) else { return Ok(Err(Error::Argument)) };+ let sweep: f64 = (0..m).filter_map(|j| arc_of(first + (begin + kk + j) % len)).map(|b| b.sweep).sum();+ let start = a.angle_on(h);+ let p = |v: Vec3| [v.x, v.y, v.z];+ match arc(k, p(a.centre), p(a.axis), p(a.reference), a.radius, start, start + sweep) {+ Ok(c) => out.push(c),+ Err(e) => return Ok(Err(e)),+ }+ }+ kk += m;+ }+ }+ first = last + 1;+ }+ Ok(Ok(out))+}++/// Runs a call that makes a new body: the kernel locked, its own status as the capi passes it.+fn making(call: &'static str, f: impl FnOnce(&mut Kernel) -> solidcore::Result<Out<Brep>>) -> Result<Body> {+ run(call, f)?.map(Body::new)+}++/// `smlib_planar_faces`: a sheet of planar faces bounded by the closed `loops`+/// (`SmApiCreatePlanarFaces`: `CreatePlanarFacesWith3DCurves` into a new B-rep's infinite region).+pub(crate) fn planar_faces(loops: &[Profile]) -> Result<Body> {+ making("smlib_planar_faces", |k| {+ let curves = match parse(k, loops) {+ Ok(c) => c,+ Err(e) => return Ok(Err(e)),+ };+ let mut b = new_brep(k, USE_DEFAULT, USE_DEFAULT)?;+ let region = b.infinite_region();+ let made = {+ let mut state = ArenaNotifyState::new(&b);+ let mut env = state.env(None);+ let key_of = env.key_of;+ let this_face = |f: FaceId| key_of(EntityRef::Face(f));+ let mut marks = Marks::default();+ let mut fenv = FaceBuildEnv { env: &mut env, marks: &mut marks, this_face: &this_face };+ // (the tolerance is not used: CreatePlanarFacesWith3DCurves takes the B-rep's)+ create_planar_faces_with_3d_curves(k, &mut b, region, &curves, 0.01, &mut fenv)+ };+ if let Err(e) = made {+ return Ok(Err(status(e)));+ }+ b.refresh_cached_topology();+ finish(b, false)+ })+}++/// `smlib_extrude`: the planar `profile` extruded `distance` along `direction`, straight+/// (`SmApiCreateLinearSweep`) or drafted (`SmApiCreateTaperExtrude`).+pub(crate) fn extrude(profile: &[Profile], direction: [f64; 3], distance: f64, draft: f64, corner: DraftCorner, cap: bool) -> Result<Body> {+ if !distance.is_finite() || !(distance > 1e-9 && distance < MAX_COORD) || !draft.is_finite() || draft.abs() >= PI / 2.0 - 1e-6 {+ return Err(Error::Argument);+ }+ making("smlib_extrude", |k| {+ let Some(dir) = unit(direction) else { return Ok(Err(Error::Argument)) };+ let curves = match parse(k, profile) {+ Ok(c) => c,+ Err(e) => return Ok(Err(e)),+ };+ if draft == 0.0 {+ // The fork's capi (7dee48f): arcs of a loop on one circle sweep one wall.+ let tol = context_zone_tol_3d(k, None, SmallTopoType::NormalSize);+ let walls = match one_wall_per_circle(k, profile, curves, tol)? {+ Ok(w) => w,+ Err(e) => return Ok(Err(e)),+ };+ let refs: Vec<Option<&Curve>> = walls.iter().map(Some).collect();+ return match create_linear_sweep(k, &refs, dir, distance, cap) {+ Ok(r) => finish(r, cap),+ Err(e) => Ok(Err(status(e))),+ };+ }+ let refs: Vec<Option<&Curve>> = curves.iter().map(Some).collect();+ // SMLib's draft extrusion takes a single chain of curves, square to the extrusion: the+ // height's sign picks the side, matched to `direction` here.+ if !one_loop(k, &curves, 1e-6)? {+ return Ok(Err(Error::Argument));+ }+ let Ok(normal) = compute_crvs_normal(k, &curves) else { return Ok(Err(Error::Argument)) };+ let along = normal.dot(dir);+ if along.abs() < 1.0 - 1e-9 {+ return Ok(Err(Error::Argument));+ }+ let height = if along > 0.0 { distance } else { -distance };+ let angle = draft * 180.0 / PI;+ // The fork's corner rules (54148db, e8f23e0): the curvature rule continues each wall as+ // itself, the tangent rule a profile of lines and arcs as their tangent planes+ // (`fixes.taper_tangent_corner_planes`), and a corner either cannot close is refused,+ // with why and where (`SmTaperCornerRefusal`, `pOptRefusedCorner`), as the capi passes it on.+ let rule = match corner {+ DraftCorner::Curvature => OffsetCornerType::CurveExtension,+ DraftCorner::Tangent => OffsetCornerType::LinearExtension,+ DraftCorner::Round => OffsetCornerType::FilletCorner,+ };+ match create_taper_extrude_with_corner(k, &refs, height, angle, if cap { 3 } else { 0 }, rule) {+ Ok(TaperExtrude::Solid(r)) => finish(r, cap),+ Ok(TaperExtrude::Refused(r)) => Ok(Err(refused(r))),+ Err(e) => Ok(Err(status(e))),+ }+ })+}++/// A refused draft corner as the capi reports it: the reason's status with the corner's point,+/// [`Error::Corner`] when the point is finite and the status's own error otherwise.+fn refused(r: CornerRefusal) -> Error {+ let (why, code) = match r.reason {+ TaperCornerRefusal::Apart => (crate::sweeps::CornerRefusal::Apart, ffi::sweeps::ERR_CORNER_APART),+ TaperCornerRefusal::WallCloses => (crate::sweeps::CornerRefusal::WallCloses, ffi::sweeps::ERR_WALL_CLOSES),+ TaperCornerRefusal::NotExact => (crate::sweeps::CornerRefusal::NotExact, ffi::trim::ERR_NOT_EXACT),+ };+ let at = [r.corner.x, r.corner.y, r.corner.z];+ if at.iter().all(|x| x.is_finite()) { Error::Corner { why, at } } else { crate::error(code) }+}++/// `smlib_revolve`: the planar `profile` turned `angle` radians about the axis through `origin`+/// along `axis` (`SmApiCreateRotationalSweep`).+pub(crate) fn revolve(profile: &[Profile], origin: [f64; 3], axis: [f64; 3], angle: f64, cap: bool) -> Result<Body> {+ if !coord_ok(&origin) || !angle.is_finite() || !(angle > 1e-9 && angle <= TAU * (1.0 + 1e-12)) {+ return Err(Error::Argument);+ }+ making("smlib_revolve", |k| {+ let Some(dir) = unit(axis) else { return Ok(Err(Error::Argument)) };+ let curves = match parse(k, profile) {+ Ok(c) => c,+ Err(e) => return Ok(Err(e)),+ };+ let refs: Vec<Option<&Curve>> = curves.iter().map(Some).collect();+ let degrees = (angle * 180.0 / PI).min(360.0);+ match create_rotational_sweep(k, &refs, v3(origin), dir, degrees, cap) {+ Ok(r) => finish(r, cap),+ Err(e) => Ok(Err(status(e))),+ }+ })+}++/// `straight`: whether the path is lines end to end along one direction; then that unit+/// direction and the path's length.+fn straight(k: &Kernel, path: &[Curve]) -> solidcore::Result<Option<(Vec3, f64)>> {+ let (mut dir, mut distance, mut prev) = (None::<Vec3>, 0.0, None::<Point3>);+ for c in path {+ if !matches!(c.kind(), CurveKind::Line(_)) {+ return Ok(None);+ }+ let (a, b) = ends(k, c)?;+ if prev.is_some_and(|p| (a - p).length() > 1e-9) {+ return Ok(None);+ }+ prev = Some(b);+ let d = b - a;+ let l = d.length();+ if !(l > 1e-12) {+ return Ok(None);+ }+ let d = d * (1.0 / l);+ match dir {+ None => dir = Some(d),+ Some(u) if d.dot(u) < 1.0 - 1e-12 => return Ok(None),+ Some(_) => {}+ }+ distance += l;+ }+ Ok(dir.map(|d| (d, distance)))+}++/// `circular`: whether the path is arcs end to end about one axis; then the centre, the unit axis+/// they turn about counter-clockwise and the total angle (radians).+fn circular(k: &Kernel, given: &[Profile], path: &[Curve]) -> solidcore::Result<Option<(Point3, Vec3, f64)>> {+ if given.len() != path.len() || path.is_empty() {+ return Ok(None);+ }+ let (mut first, mut prev, mut angle) = (None::<(Point3, Vec3, f64)>, None::<Point3>, 0.0);+ for (g, c) in given.iter().zip(path) {+ let Profile::Arc { center, axis, radius, start, end, .. } = g else { return Ok(None) };+ let (ctr, kv) = (v3(*center), v3(*axis));+ let kv = kv * (1.0 / kv.length());+ let (a, b) = ends(k, c)?;+ match first {+ None => first = Some((ctr, kv, *radius)),+ Some((c0, k0, r0)) => {+ if (ctr - c0).length() > 1e-9+ || kv.dot(k0) < 1.0 - 1e-12+ || (radius - r0).abs() > 1e-9+ || prev.is_none_or(|p| (a - p).length() > 1e-9)+ {+ return Ok(None);+ }+ }+ }+ prev = Some(b);+ angle += end - start;+ }+ Ok(first.filter(|_| angle <= TAU * (1.0 + 1e-12)).map(|(c, kv, _)| (c, kv, angle)))+}++/// A curve's B-spline (`SM_CAST_PTR(SmBSplineCurve, c)`: SMLib's lines and circles are+/// B-splines too); `None` for another kind.+fn bspline(c: &Curve) -> solidcore::Result<Option<BSplineCurve>> {+ Ok(match c.kind() {+ CurveKind::BSpline(b) => Some(b.clone()),+ CurveKind::Line(l) => Some(l.base_with_nurb()?.into_owned()),+ CurveKind::Ellipse(e) => Some(e.base().clone()),+ _ => None,+ })+}++/// `joined`: a path of end-to-end curves as one B-spline (`CreateCurveSweep` takes one curve).+fn joined(path: &[Curve]) -> solidcore::Result<Out<BSplineCurve>> {+ let mut parts = Vec::with_capacity(path.len());+ for c in path {+ let Some(b) = bspline(c)? else { return Ok(Err(Error::Argument)) };+ parts.push(b);+ }+ if parts.len() == 1 {+ return Ok(parts.pop().ok_or(Error::Argument));+ }+ Ok(called(BSplineCurve::create_by_joining(&mut parts, None)))+}++/// `turned`: `v` turned `angle` right-handed about the unit `k` (Rodrigues).+fn turned(v: Vec3, k: Vec3, angle: f64) -> Vec3 {+ v * angle.cos() + k.cross(v) * angle.sin() + k * (k.dot(v) * (1.0 - angle.cos()))+}++/// `put_motion`: a placement as its columns and translation.+fn motion(x: Vec3, y: Vec3, z: Vec3, t: Vec3) -> Affine {+ Affine { m: [[x.x, x.y, x.z], [y.x, y.y, y.z], [z.x, z.y, z.z]], t: [t.x, t.y, t.z] }+}++/// A rigid motion p -> R p + t, R by its columns (`Rigid`).+#[derive(Clone, Copy)]+struct Rigid {+ x: Vec3,+ y: Vec3,+ z: Vec3,+ t: Vec3,+}++impl Rigid {+ const IDENTITY: Rigid =+ Rigid { x: Vec3::new(1.0, 0.0, 0.0), y: Vec3::new(0.0, 1.0, 0.0), z: Vec3::new(0.0, 0.0, 1.0), t: Vec3::new(0.0, 0.0, 0.0) };++ /// This motion, then a turn of `angle` right-handed about the unit `k` through `c`.+ fn turned_by(&self, c: Vec3, k: Vec3, angle: f64) -> Rigid {+ Rigid { x: turned(self.x, k, angle), y: turned(self.y, k, angle), z: turned(self.z, k, angle), t: c + turned(self.t - c, k, angle) }+ }++ /// This motion, then a move by `d`.+ fn moved_by(&self, d: Vec3) -> Rigid {+ Rigid { t: self.t + d, ..*self }+ }++ /// As the placement `SmCurve::Transform` takes: the world frame's image.+ fn placement(&self) -> Axis2Placement {+ Axis2Placement::new(self.t, self.x, self.y)+ }++ fn motion(&self) -> Affine {+ motion(self.x, self.y, self.z, self.t)+ }+}++/// One segment of a path of lines and arcs (`Segment`): a line from `a` along the unit `dir` for+/// `length`, or an arc turning `angle` (radians) right-handed about the unit `k` through `c`,+/// `length` along.+#[derive(Clone, Copy)]+struct Segment {+ arc: bool,+ dir: Vec3,+ c: Vec3,+ k: Vec3,+ angle: f64,+ length: f64,+}++impl Segment {+ /// The motion `m` carried `s` of the way along (0 <= s <= length).+ fn carry(&self, m: &Rigid, s: f64) -> Rigid {+ if self.arc { m.turned_by(self.c, self.k, self.angle * s / self.length) } else { m.moved_by(self.dir * s) }+ }+}++/// `segmented`: whether `path` (parsed from `given`) is two or more lines and arcs end to end,+/// each leaving in the direction the one before arrives in, and not closed: then its segments.+fn segmented(k: &Kernel, given: &[Profile], path: &[Curve]) -> solidcore::Result<Option<Vec<Segment>>> {+ if given.len() != path.len() || path.len() < 2 {+ return Ok(None);+ }+ let unit = |v: Vec3| v * (1.0 / v.length());+ let mut out = Vec::with_capacity(path.len());+ // The direction the path arrives in at the end of the segment before, and where it ends.+ let (mut before, mut first, mut prev) = (None::<Vec3>, None::<Point3>, None::<Point3>);+ for (g, c) in given.iter().zip(path) {+ let (a, b) = ends(k, c)?;+ let (seg, leaving, arriving) = match g {+ Profile::Line { .. } => {+ let length = (b - a).length();+ if !(length > 1e-12) {+ return Ok(None);+ }+ let dir = (b - a) * (1.0 / length);+ (Segment { arc: false, dir, c: Vec3::new(0.0, 0.0, 0.0), k: Vec3::new(0.0, 0.0, 0.0), angle: 0.0, length }, dir, dir)+ }+ Profile::Arc { center, axis, radius, start, end, .. } => {+ let (ctr, kv) = (v3(*center), unit(v3(*axis)));+ let angle = end - start;+ let seg = Segment { arc: true, dir: Vec3::new(0.0, 0.0, 0.0), c: ctr, k: kv, angle, length: radius * angle };+ (seg, unit(kv.cross(a - ctr)), unit(kv.cross(b - ctr)))+ }+ _ => return Ok(None),+ };+ match (first, prev, before) {+ (None, ..) => first = Some(a),+ (Some(_), Some(p), Some(d)) => {+ if (a - p).length() > 1e-9 || leaving.dot(d) < 1.0 - 1e-12 {+ return Ok(None);+ }+ }+ _ => return Ok(None),+ }+ prev = Some(b);+ before = Some(arriving);+ out.push(seg);+ }+ match (first, prev) {+ (Some(f), Some(p)) if (f - p).length() > 1e-6 => Ok(Some(out)),+ _ => Ok(None),+ }+}++/// `carried`: copies of the profile's curves carried by `m`.+fn carried(k: &Kernel, profile: &[Curve], m: &Rigid) -> solidcore::Result<Vec<Curve>> {+ let at = m.placement();+ let mut out = Vec::with_capacity(profile.len());+ for c in profile {+ let mut copy = c.clone();+ copy.transform(k, &at, None).map_err(|_| SolidError::sm_err("SmCurve::Transform"))?;+ out.push(copy);+ }+ Ok(out)+}++/// `piecewise`: the profile swept along a path of lines and arcs, turning with it: each segment+/// swept on its own, exactly (a line by SM_API's linear sweep, an arc by its rotational sweep), the+/// profile carried from each to the next, and the walls sewn along the sections they share; with+/// the motions to the first section, the one half-way along and the last.+fn piecewise(k: &mut Kernel, profile: &[Curve], segs: &[Segment], cap: bool) -> solidcore::Result<Out<(Brep, [Affine; 3])>> {+ let mut b = new_brep(k, USE_DEFAULT, USE_DEFAULT)?;+ let mut m = Rigid::IDENTITY;+ let mut starts = Vec::with_capacity(segs.len());+ let mut total = 0.0;+ for g in segs {+ starts.push(m);+ total += g.length;+ let section = carried(k, profile, &m)?;+ let refs: Vec<Option<&Curve>> = section.iter().map(Some).collect();+ let piece = if g.arc {+ create_rotational_sweep(k, &refs, g.c, g.k, g.angle * 180.0 / PI, false)+ } else {+ create_linear_sweep(k, &refs, g.dir, g.length, false)+ };+ let mut piece = match piece {+ Ok(p) => p,+ Err(e) => return Ok(Err(status(e))),+ };+ let faces = brep_p1::faces(&piece, None)?;+ let mut state = ArenaNotifyState::new(&piece);+ state.seed(&b);+ let mut env = state.env(None);+ let key_of = env.key_of;+ let this_face = |f: FaceId| key_of(EntityRef::Face(f));+ match copy_faces(k, &mut piece, &faces, &mut b, false, &this_face, &mut env) {+ Ok((_, true)) => {}+ Ok((_, false)) => return Ok(Err(status(SolidError::sm_err("CopyFaces")))),+ Err(e) => return Ok(Err(status(e))),+ }+ m = g.carry(&m, g.length);+ }+ let Some(&start) = starts.first() else { return Ok(Err(Error::Argument)) };+ if cap {+ // The caps: the profile where the path starts and where it ends.+ for at in [start, m] {+ let section = carried(k, profile, &at)?;+ let (region, tol) = (b.infinite_region(), b.tolerance());+ if let Err(e) = build_faces(&mut b, |b, fenv| create_planar_faces_with_3d_curves(k, b, region, §ion, tol, fenv)) {+ return Ok(Err(status(e)));+ }+ }+ }+ if let Err(e) = stitch_and_orient(k, &mut b, &StitchAndOrientOptions::default()) {+ return Ok(Err(status(e)));+ }+ b.refresh_cached_topology();+ let mut half = 0.5 * total;+ let mut middle = m;+ for (i, (g, from)) in segs.iter().zip(&starts).enumerate() {+ if half <= g.length || i + 1 == segs.len() {+ middle = g.carry(from, half.min(g.length));+ break;+ }+ half -= g.length;+ }+ Ok(Ok((b, [start.motion(), middle.motion(), m.motion()])))+}++/// `smlib_sweep_placed`: `profile` swept along `path`, with the rigid motions that placed it at+/// the start, half way and the end. Along a straight path the sweep is SM_API's linear sweep, and+/// turning with arcs about one axis its rotational sweep: both build the walls exactly, as the+/// sweep piece by piece does along lines and arcs that turn with the path ([`piecewise`]).+pub(crate) fn sweep_placed(profile: &[Profile], path: &[Profile], frame: SweepFrame, cap: bool) -> Result<(Body, [Affine; 3])> {+ let mut placed = [motion(Vec3::new(1.0, 0.0, 0.0), Vec3::new(0.0, 1.0, 0.0), Vec3::new(0.0, 0.0, 1.0), Vec3::new(0.0, 0.0, 0.0)); 3];+ let body = making("smlib_sweep", |k| {+ let (curves, along) = match (parse(k, profile), parse(k, path)) {+ (Ok(c), Ok(p)) => (c, p),+ (Err(e), _) | (_, Err(e)) => return Ok(Err(e)),+ };+ let refs: Vec<Option<&Curve>> = curves.iter().map(Some).collect();+ if let Some((dir, distance)) = straight(k, &along)? {+ let r = match create_linear_sweep(k, &refs, dir, distance, cap) {+ Ok(r) => r,+ Err(e) => return Ok(Err(status(e))),+ };+ for (j, m) in placed.iter_mut().enumerate() {+ let t = dir * (distance * 0.5 * j as f64);+ m.t = [t.x, t.y, t.z];+ }+ return finish(r, cap);+ }+ if frame == SweepFrame::Follow+ && let Some((centre, axis, angle)) = circular(k, path, &along)?+ {+ let degrees = (angle * 180.0 / PI).min(360.0);+ let r = match create_rotational_sweep(k, &refs, centre, axis, degrees, cap) {+ Ok(r) => r,+ Err(e) => return Ok(Err(status(e))),+ };+ let len = axis.length();+ if !(len > 0.0) {+ return Ok(Err(Error::Argument));+ }+ let kv = axis * (1.0 / len);+ let turn = degrees * PI / 180.0;+ for (j, m) in placed.iter_mut().enumerate() {+ let a = turn * 0.5 * j as f64;+ let t = centre - turned(centre, kv, a);+ let [x, y, z] = [Vec3::new(1.0, 0.0, 0.0), Vec3::new(0.0, 1.0, 0.0), Vec3::new(0.0, 0.0, 1.0)].map(|e| turned(e, kv, a));+ *m = motion(x, y, z, t);+ }+ return finish(r, cap);+ }+ // Along lines and arcs, turning with the path, the sweep is exact piece by piece.+ if frame == SweepFrame::Follow+ && let Some(segs) = segmented(k, path, &along)?+ {+ return Ok(match piecewise(k, &curves, &segs, cap)? {+ Ok((b, motions)) => {+ placed = motions;+ finish(b, cap)?+ }+ Err(e) => Err(e),+ });+ }+ let path_curve = match joined(&along)? {+ Ok(b) => Curve::from(b),+ Err(e) => return Ok(Err(e)),+ };+ // Round a closed path the profile comes back onto itself: the walls close on each other+ // there, where caps would lie on top of each other inside the solid.+ let (Some(head), Some(tail)) = (along.first(), along.last()) else { return Ok(Err(Error::Argument)) };+ let closed = (ends(k, head)?.0 - ends(k, tail)?.1).length() <= 1e-6;+ // `SmApiCreateCurveSweep` with `bProfileAtPathStart` (fork 2dd71a0), so the profile is+ // swept where it lies, and the placements it reports (fork 5d3939e).+ let options = SweepOptions {+ cap_ends: cap && !closed,+ translational_sweep: frame == SweepFrame::Translate,+ profile_at_path_start: true,+ ..SweepOptions::default()+ };+ let r = match create_curve_sweep_with_placements(k, &refs, Some(&path_curve), None, None, Some(&options)) {+ Ok(r) => r,+ Err(e) => return Ok(Err(status(e))),+ };+ for (m, p) in placed.iter_mut().zip(&r.placements) {+ *m = motion(p.x_axis(), p.y_axis(), p.z_axis(), p.origin());+ }+ let mut b = r.sweep.brep;+ if closed {+ let tol = b.tolerance();+ match stitch_faces(k, &mut b, tol, None, false) {+ Ok(s) if s.lamina_edges != 0 => return Ok(Err(Error::NotSolid)),+ Ok(_) => b.refresh_cached_topology(),+ Err(e) => return Ok(Err(status(e))),+ }+ }+ finish(b, cap)+ })?;+ Ok((body, placed))+}++/// `smlib_loft`: a skin through `sections` (`SmApiCreateSkinPrimitive`), `degree` across them.+pub(crate) fn loft(sections: &[Vec<Profile>], degree: u32, cap: bool) -> Result<Body> {+ if sections.len() < 2 || sections.len() > MAX_CURVES || !(1..=3).contains(°ree) {+ return Err(Error::Argument);+ }+ let all: Vec<Profile> = sections.iter().flatten().cloned().collect();+ making("smlib_loft", |k| {+ let curves = match parse(k, &all) {+ Ok(c) => c,+ Err(e) => return Ok(Err(e)),+ };+ if sections.iter().any(|s| s.is_empty() || s.len() > MAX_CURVES) {+ return Ok(Err(Error::Argument));+ }+ let counts: Vec<usize> = sections.iter().map(Vec::len).collect();+ let refs: Vec<Option<&Curve>> = curves.iter().map(Some).collect();+ match create_skin_primitive(k, &counts, &refs, degree as usize, cap) {+ Ok(r) => finish(r.brep, cap),+ Err(e) => Ok(Err(status(e))),+ }+ })+}++/// Each face's identity, for the face builders: their arena identity.+pub(super) fn build_faces<T>(b: &mut Brep, f: impl FnOnce(&mut Brep, &mut FaceBuildEnv<'_, '_>) -> T) -> T {+ let mut state = ArenaNotifyState::new(b);+ let mut env = state.env(None);+ let key_of = env.key_of;+ let this_face = |f: FaceId| key_of(EntityRef::Face(f));+ let mut marks = Marks::default();+ let mut fenv = FaceBuildEnv { env: &mut env, marks: &mut marks, this_face: &this_face };+ f(b, &mut fenv)+}++/// `smlib_loft_to_point`: a pyramid from the planar `section` (one closed loop of lines, in+/// order) to `apex`: the base and a triangle on each line, each `CreatePlanarFaceWith3DCurves` of+/// new lines, then `StitchAndOrient`.+pub(crate) fn loft_to_point(section: &[Profile], apex: [f64; 3]) -> Result<Body> {+ if !coord_ok(&apex) {+ return Err(Error::Argument);+ }+ making("smlib_loft_to_point", |k| {+ let curves = match parse(k, section) {+ Ok(c) => c,+ Err(e) => return Ok(Err(e)),+ };+ if curves.len() < 3 || !one_loop(k, &curves, 1e-6)? {+ return Ok(Err(Error::Argument));+ }+ // The base's corners, each line's start.+ let mut corners = Vec::with_capacity(curves.len());+ for c in &curves {+ if !matches!(c.kind(), CurveKind::Line(_)) {+ return Ok(Err(Error::Argument));+ }+ corners.push(ends(k, c)?.0);+ }+ let Ok(normal) = compute_crvs_normal(k, &curves) else { return Ok(Err(Error::Argument)) };+ let top = v3(apex);+ let Some(&c0) = corners.first() else { return Ok(Err(Error::Argument)) };+ let size = corners.iter().map(|q| (*q - c0).length()).fold(0.0, f64::max);+ if !((top - c0).dot(normal).abs() > 1e-9 * size.max(1.0)) {+ return Ok(Err(Error::Argument));+ }+ let mut b = new_brep(k, USE_DEFAULT, USE_DEFAULT)?;+ let region = b.infinite_region();+ let tol = 1e-6;+ let made = build_faces(&mut b, |b, fenv| -> Out<()> {+ let mut face = |b: &mut Brep, fenv: &mut FaceBuildEnv<'_, '_>, pts: &[Point3]| -> Out<()> {+ let mut edges = Vec::with_capacity(pts.len());+ for (i, &p) in pts.iter().enumerate() {+ let q = pts.get((i + 1) % pts.len()).copied().unwrap_or(p);+ edges.push(Curve::from(called(Line::create_line_segment(3, p, q, None))?));+ }+ called(create_planar_face_with_3d_curves(k, b, region, &edges, tol, fenv)).map(|_| ())+ };+ face(b, fenv, &corners)?;+ for (i, &p) in corners.iter().enumerate() {+ let q = corners.get((i + 1) % corners.len()).copied().unwrap_or(p);+ face(b, fenv, &[p, q, top])?;+ }+ Ok(())+ });+ if let Err(e) = made {+ return Ok(Err(e));+ }+ if let Err(e) = stitch_and_orient(k, &mut b, &StitchAndOrientOptions::default()) {+ return Ok(Err(status(e)));+ }+ b.refresh_cached_topology();+ finish(b, true)+ })+}++/// `maps_ok`: each station map finite, of bounded size and far from singular, its translation+/// within `MAX_COORD`.+fn maps_ok(stations: &[Affine]) -> bool {+ stations.iter().all(|s| {+ let m = &s.m;+ if !m.iter().flatten().chain(&s.t).all(|x| x.is_finite()) || !coord_ok(&s.t) {+ return false;+ }+ let len = |c: &[f64; 3]| (c[0] * c[0] + c[1] * c[1] + c[2] * c[2]).sqrt();+ let (c0, c1, c2) = (len(&m[0]), len(&m[1]), len(&m[2]));+ if !(c0 < 1e6 && c1 < 1e6 && c2 < 1e6) {+ return false;+ }+ let det = m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2]) - m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])+ + m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);+ det.abs() > 1e-9 * c0 * c1 * c2+ })+}++/// `placed`: a copy of `c` as a plain B-spline with every control point carried by `s`, the+/// weights unchanged (an affine map moves a NURBS curve exactly by its control points).+fn placed(c: &BSplineCurve, s: &Affine) -> Out<Curve> {+ let can = called(c.canonical())?;+ if can.dim != 3 {+ return Err(Error::Status(1001));+ }+ let m = &s.m;+ let points: Vec<Point3> = can+ .control_points+ .iter()+ .map(|p| {+ Vec3::new(+ m[0][0] * p.x + m[1][0] * p.y + m[2][0] * p.z + s.t[0],+ m[0][1] * p.x + m[1][1] * p.y + m[2][1] * p.z + s.t[1],+ m[0][2] * p.x + m[1][2] * p.y + m[2][2] * p.z + s.t[2],+ )+ })+ .collect();+ let data = CanonicalData {+ dim: 3,+ degree: can.degree,+ control_points: &points,+ form: BSplineCurveForm::Unspecified,+ knot_multiplicities: &can.knot_multiplicities,+ knots: &can.knots,+ knot_type: KnotType::Unspecified,+ weights: (!can.weights.is_empty()).then_some(can.weights.as_slice()),+ trim: None,+ };+ called(BSplineCurve::create_canonical(&data)).map(Curve::from)+}++/// `smlib_sweep_stations`: the profile placed by each station, its sections skinned through+/// (`SmApiCreateSkinPrimitive`, cubic across them or as high as their number allows), the ends+/// capped, or joined by `SmApiStitchIntoSolid`.+pub(crate) fn sweep_stations(profile: &[Profile], stations: &[Affine], end: Ends) -> Result<Body> {+ if !(2..=MAX_STATIONS).contains(&stations.len()) {+ return Err(Error::Argument);+ }+ making("smlib_sweep_stations", |k| {+ if !maps_ok(stations) {+ return Ok(Err(Error::Argument));+ }+ let curves = match parse(k, profile) {+ Ok(c) => c,+ Err(e) => return Ok(Err(e)),+ };+ if curves.len() as f64 * stations.len() as f64 > MAX_STATION_CURVES as f64 {+ return Ok(Err(Error::Argument));+ }+ // Every section is the profile carried by its station's map: the sections share the+ // profile's degrees and knots, which the skin interpolates control point by control point.+ let mut sections = Vec::with_capacity(curves.len() * stations.len());+ let mut counts = Vec::with_capacity(stations.len());+ for s in stations {+ for c in &curves {+ let Some(b) = bspline(c)? else { return Ok(Err(Error::Argument)) };+ match placed(&b, s) {+ Ok(p) => sections.push(p),+ Err(e) => return Ok(Err(e)),+ }+ }+ counts.push(curves.len());+ }+ let degree = (stations.len() - 1).min(3);+ let refs: Vec<Option<&Curve>> = sections.iter().map(Some).collect();+ let mut r = match create_skin_primitive(k, &counts, &refs, degree, end == Ends::Capped) {+ Ok(r) => r.brep,+ Err(e) => return Ok(Err(status(e))),+ };+ if end == Ends::Joined {+ // The last section lies on the first: the walls' ends are glued to their starts.+ match api_stitch_into_solid(k, Some(&mut r)) {+ Ok(s) if s.produces_a_solid => {}+ Ok(_) => return Ok(Err(Error::NotSolid)),+ Err(e) => return Ok(Err(status(e))),+ }+ }+ finish(r, end != Ends::Open)+ })+}++/// The entry checks of `smlib_screw_sweep` and `smlib_screw_sweep_radial`.+fn screw_ok(origin: [f64; 3], pitch: f64, turns: f64, tolerance: f64) -> bool {+ coord_ok(&origin)+ && pitch.is_finite()+ && pitch.abs() > 1e-6+ && pitch.abs() < MAX_COORD+ && turns.is_finite()+ && (1e-3..=SCREW_MAX_TURNS).contains(&turns)+ && tolerance.is_finite()+ && (1e-6..1e3).contains(&tolerance)+}++/// `SMLIB_SCREW_MAX_STATIONS`: most spans of one screw sweep.+const SCREW_MAX_STATIONS: f64 = 12000.0;++/// `Screw`: the screw motion about the axis through `o` along the unit `k`, rising `pitch` per+/// turn, the section carried by angle a (radians, right-handed about k) and first moved off the+/// axis by offset(a) along `e` (the radial sweep: the unit direction from the axis into the+/// profile's half-plane), offset(a) piecewise linear through (`angles`, `offsets`) and held+/// beyond them. No offsets: none.+struct Screw {+ o: Point3,+ k: Vec3,+ e: Vec3,+ pitch: f64,+ angles: Vec<f64>,+ offsets: Vec<f64>,+}++impl Screw {+ fn turn(&self, v: Vec3, a: f64) -> Vec3 {+ turned(v, self.k, a)+ }++ fn lift(&self, a: f64) -> f64 {+ self.pitch * a / TAU+ }++ fn offset(&self, a: f64) -> f64 {+ let (Some(&a0), Some(&o0), Some(&on)) = (self.angles.first(), self.offsets.first(), self.offsets.last()) else { return 0.0 };+ if !(a > a0) {+ return o0;+ }+ for i in 1..self.angles.len() {+ let (Some(&ai), Some(&ap), Some(&oi), Some(&op)) =+ (self.angles.get(i), self.angles.get(i - 1), self.offsets.get(i), self.offsets.get(i - 1))+ else {+ break;+ };+ if a <= ai {+ return op + (oi - op) * (a - ap) / (ai - ap);+ }+ }+ on+ }++ /// The move off the axis at angle a, before the turn.+ fn shift(&self, a: f64) -> Vec3 {+ if self.offsets.is_empty() { Vec3::new(0.0, 0.0, 0.0) } else { self.e * self.offset(a) }+ }++ /// Where p goes at angle a.+ fn at(&self, p: Point3, a: f64) -> Point3 {+ self.o + self.turn(p - self.o + self.shift(a), a) + self.k * self.lift(a)+ }++ /// How far p lies from the axis.+ fn reach(&self, p: Point3) -> f64 {+ let w = p - self.o;+ (w - self.k * w.dot(self.k)).length()+ }+}++/// `Stations`: n spans of h radians each, from t[0] to t[n]. Each span carries the profile round+/// as an exact rational quadratic arc carries a point (its middle control point at the span's+/// middle angle, out by 1 / cos(h / 2), weighted cos(h / 2)), and lifts it by the same rational+/// quadratic of the lifts at the span's ends and middle.+struct Stations {+ t: Vec<f64>,+ /// h / 2.+ half: f64,+}++impl Stations {+ fn new(from: f64, to: f64, n: usize) -> Stations {+ let t = (0..=n).map(|i| if i == n { to } else { from + (to - from) * i as f64 / n as f64 }).collect();+ Stations { t, half: 0.5 * (to - from) / n as f64 }+ }++ fn spans(&self) -> usize {+ self.t.len() - 1+ }++ fn first(&self) -> f64 {+ self.t.first().copied().unwrap_or(0.0)+ }++ fn last(&self) -> f64 {+ self.t.last().copied().unwrap_or(0.0)+ }++ /// The knots across the stations: double inside (the arcs meet tangent), triple at the ends.+ fn knots(&self) -> (Vec<f64>, Vec<usize>) {+ let n = self.t.len();+ (self.t.clone(), (0..n).map(|i| if i == 0 || i + 1 == n { 3 } else { 2 }).collect())+ }++ /// The weight of control point j (of 2 spans + 1) across the stations.+ fn weight(&self, j: usize) -> f64 {+ if j.is_multiple_of(2) { 1.0 } else { self.half.cos() }+ }+}++/// `lift_error`: how far, in radians of turn, the rational quadratic lift of a span of+/// half-angle `half` leads or lags the true lift, at most (about 0.008 h³).+fn lift_error(half: f64) -> f64 {+ let mut worst: f64 = 0.0;+ for i in 0..=2048 {+ let s = i as f64 / 2048.0;+ let lift = half * s / (1.0 - (1.0 - s * s) * (1.0 - half.cos()) / 2.0);+ worst = worst.max((lift - 2.0 * ((half / 2.0).tan() * s).atan()).abs());+ }+ worst+}++/// `offset_error`: how far, per unit change of offset across a span of half-angle `half`, the+/// rational quadratic offset strays from the true offset turned with the profile, at most+/// (about h / 8).+fn offset_error(half: f64) -> f64 {+ let (c, h) = (half.cos(), 2.0 * half);+ let mut worst: f64 = 0.0;+ for i in 0..=4096 {+ let s = -1.0 + i as f64 / 2048.0;+ let t = 0.5 * (s + 1.0);+ let (b0, b1, b2) = ((1.0 - t) * (1.0 - t), 2.0 * t * (1.0 - t), t * t);+ let den = b0 + c * b1 + b2;+ let (ax, ay) = (0.5 * (b2 - b0) * c / den, 0.5 * (b2 + b0) * half.sin() / den);+ let phi = 2.0 * ((half / 2.0).tan() * s).atan();+ worst = worst.max((ax - phi / h * phi.cos()).hypot(ay - phi / h * phi.sin()));+ }+ worst+}++/// `path`: the control points of p's path under the screw motion over `st` (2 spans + 1).+fn screw_path(m: &Screw, p: Point3, st: &Stations) -> Vec<Point3> {+ let w = p - m.o;+ let axial = w.dot(m.k);+ let radial = w - m.k * axial;+ let mut d = Vec::with_capacity(2 * st.spans() + 1);+ for (i, &ti) in st.t.iter().enumerate() {+ d.push(m.at(p, ti));+ if let Some(&tn) = st.t.get(i + 1) {+ let mid = 0.5 * (ti + tn);+ d.push(m.o + m.turn(radial + m.shift(mid), mid) * (1.0 / st.half.cos()) + m.k * (axial + m.lift(mid)));+ }+ }+ d+}++/// `path_curve`: the path of p over `st` as a curve, exactly as the walls either side have it.+fn path_curve(m: &Screw, p: Point3, st: &Stations) -> Out<Curve> {+ let points = screw_path(m, p, st);+ let weights: Vec<f64> = (0..points.len()).map(|j| st.weight(j)).collect();+ let (knots, mult) = st.knots();+ let data = CanonicalData {+ dim: 3,+ degree: 2,+ control_points: &points,+ form: BSplineCurveForm::Unspecified,+ knot_multiplicities: &mult,+ knots: &knots,+ knot_type: KnotType::Unspecified,+ weights: Some(&weights),+ trim: None,+ };+ called(BSplineCurve::create_canonical(&data)).map(Curve::from)+}++/// `axial_radius`: the radius of the cylinder a profile line parallel to the axis sweeps (within+/// a thousandth of `tolerance`, at least 1e-6 off it); 0 for any other curve.+fn axial_radius(k: &Kernel, m: &Screw, c: &Curve, tolerance: f64) -> solidcore::Result<f64> {+ if !matches!(c.kind(), CurveKind::Line(_)) {+ return Ok(0.0);+ }+ let (a, b) = ends(k, c)?;+ // How far a point of the line strays from the axis lies between the ends' and the nearest+ // point's (the distance is convex along the line).+ let (w, d) = (a - m.o, b - a);+ let (wp, dp) = (w - m.k * w.dot(m.k), d - m.k * d.dot(m.k));+ let t = if dp.dot(dp) > 0.0 { (-wp.dot(dp) / dp.dot(dp)).clamp(0.0, 1.0) } else { 0.0 };+ let (ra, rb, nearest) = (m.reach(a), m.reach(b), (wp + dp * t).length());+ let (far, near) = (ra.max(rb), nearest.min(ra.min(rb)));+ Ok(if near >= 1e-6 && far - near <= 1e-3 * tolerance { 0.5 * (ra + rb) } else { 0.0 })+}++/// `cylinder_piece`: the piece of the cylinder of `radius` the profile line from `a` to `b`+/// sweeps over `st`: an exact cylinder about the axis, bounded by the line placed at both ends of+/// the piece and its ends' paths (`CreateFacesWithCurves`). The cylinder's own turn starts a+/// quarter turn before the piece and its height runs past it.+fn cylinder_piece(k: &mut Kernel, b: &mut Brep, m: &Screw, a: Point3, e: Point3, radius: f64, st: &Stations) -> solidcore::Result<Out<()>> {+ let (a0, a1) = (st.first(), st.last());+ let w = a - m.o;+ let r = w - m.k * w.dot(m.k);+ let r = r * (1.0 / r.length());+ let x = m.turn(r, a0 - 0.25 * TAU);+ let y = m.k.cross(x);+ let (za, zb) = ((a - m.o).dot(m.k), (e - m.o).dot(m.k));+ let z0 = za.min(zb) + m.lift(a0).min(m.lift(a1));+ let z1 = za.max(zb) + m.lift(a0).max(m.lift(a1));+ let margin = 0.25 * (z1 - z0) + 1e-3;+ let base = m.o + m.k * (z0 - margin);+ let cylinder = Cone::new_cylinder_bounded(base, x, y, radius, 0.0, 360.0, z1 - z0 + 2.0 * margin, false, false, false);+ let edge = |at: f64| called(Line::create_line_segment(3, m.at(a, at), m.at(e, at), None)).map(Curve::from);+ let lp = || -> Out<Vec<Curve>> { Ok(vec![edge(a0)?, path_curve(m, e, st)?, edge(a1)?, path_curve(m, a, st)?]) };+ let curves = match lp() {+ Ok(c) => c,+ Err(err) => return Ok(Err(err)),+ };+ let orient = [OrientType::Same, OrientType::Same, OrientType::Opposite, OrientType::Opposite];+ let region = b.infinite_region();+ let made = build_faces(b, |b, fenv| {+ create_faces_with_curves(k, b, region, &[4], Some(curves.into_iter().map(Some).collect()), &orient, Some(Surface::from(cylinder)), fenv)+ });+ Ok(match made {+ Ok(f) if f.faces.len() == 1 => Ok(()),+ Ok(_) => Err(Error::Status(1001)),+ Err(err) => Err(status(err)),+ })+}++/// `screw_wall`: the wall one profile curve sweeps over `st`: across the curve its NURBS, across+/// the turns each control point's path, the weights the curve's times the arcs'.+fn screw_wall(m: &Screw, c: &CurveCanonical, st: &Stations) -> Out<Surface> {+ let across = 2 * st.spans() + 1;+ let mut net = Vec::with_capacity(c.control_points.len() * across);+ let mut weights = Vec::with_capacity(net.capacity());+ for (l, &p) in c.control_points.iter().enumerate() {+ let w = c.weights.get(l).copied().unwrap_or(1.0);+ for (j, q) in screw_path(m, p, st).into_iter().enumerate() {+ net.push(q);+ weights.push(w * st.weight(j));+ }+ }+ let (vknots, vmult) = st.knots();+ let data = CanonicalSurfaceData {+ u_degree: c.degree,+ v_degree: 2,+ control_points: &net,+ form: BSplineSurfaceForm::Unspecified,+ u_multiplicities: &c.knot_multiplicities,+ v_multiplicities: &vmult,+ u_knots: &c.knots,+ v_knots: &vknots,+ knot_type: KnotType::Unspecified,+ weights: Some(&weights),+ uv_domain: None,+ };+ called(BSplineSurface::create_canonical(&data)).map(Surface::from)+}++/// The profile curve `c` carried by the screw motion's placement at angle `a` (`Copy`, then+/// `Transform`): a rigid motion, so a line stays a line and an arc an arc.+fn screw_placed(m: &Screw, c: &Profile, a: f64) -> Profile {+ let p = |q: [f64; 3]| {+ let r = m.at(v3(q), a);+ [r.x, r.y, r.z]+ };+ let d = |q: [f64; 3]| {+ let r = m.turn(v3(q), a);+ [r.x, r.y, r.z]+ };+ match c {+ Profile::Line { start, end } => Profile::Line { start: p(*start), end: p(*end) },+ Profile::Arc { center, axis, reference, radius, start, end } => {+ Profile::Arc { center: p(*center), axis: d(*axis), reference: d(*reference), radius: *radius, start: *start, end: *end }+ }+ Profile::Nurbs { degree, points, knots } => Profile::Nurbs {+ degree: *degree,+ points: points+ .iter()+ .map(|q| {+ let r = p([q[0], q[1], q[2]]);+ [r[0], r[1], r[2], q[3]]+ })+ .collect(),+ knots: knots.clone(),+ },+ }+}++/// `screw_sweep` (smlib_sweeps.cpp): the profile's walls built from the screw motion itself, span+/// by span (SM_API's curve sweep carries the profile on its own frame, which along a helix turns+/// it away from the screw motion), lines parallel to the axis as exact cylinder pieces, the caps+/// where the motion starts and ends, all stitched and oriented.+fn screw(k: &mut Kernel, profile: &[Profile], mut m: Screw, turns: f64, tolerance: f64) -> solidcore::Result<Out<Brep>> {+ let curves = match parse(k, profile) {+ Ok(c) => c,+ Err(e) => return Ok(Err(e)),+ };+ let mut walls = Vec::with_capacity(curves.len());+ let (mut reach, mut farthest) = (0.0, Vec3::new(0.0, 0.0, 0.0));+ for c in &curves {+ let Some(b) = bspline(c)? else { return Ok(Err(Error::Status(1001))) };+ let can = b.canonical()?;+ if can.dim != 3 {+ return Ok(Err(Error::Status(1001)));+ }+ for &p in &can.control_points {+ let v = p - m.o;+ let v = v - m.k * v.dot(m.k);+ if v.length() > reach {+ reach = v.length();+ farthest = v;+ }+ }+ walls.push(can);+ }+ if !(reach > 1e-6) {+ return Ok(Err(Error::Argument));+ }+ // An offset moves the profile within its half-plane: every control point must lie in the one+ // the farthest of them spans with the axis, and stay off the axis moved.+ if !m.offsets.is_empty() {+ let mut nearest = reach;+ m.e = farthest * (1.0 / reach);+ for p in walls.iter().flat_map(|w| &w.control_points) {+ let v = *p - m.o;+ let v = v - m.k * v.dot(m.k);+ let along = v.dot(m.e);+ if !((v - m.e * along).length() <= 1e-9 * (1.0 + reach) && along >= -1e-9 * (1.0 + reach)) {+ return Ok(Err(Error::Argument));+ }+ nearest = nearest.min(along);+ }+ if m.offsets.iter().any(|d| !(nearest + d > 1e-6)) {+ return Ok(Err(Error::Argument));+ }+ }+ // Walls of lines parallel to the axis are exact cylinders, which cannot turn on themselves:+ // then every wall comes in pieces of half a turn (the last up to an eighth longer).+ let mut radius = Vec::with_capacity(curves.len());+ for c in &curves {+ radius.push(axial_radius(k, &m, c, tolerance)?);+ }+ let cylinders = radius.iter().any(|&r| r > 0.0);+ // The offset changes slope only at its own angles: they bound pieces too, and a half turn+ // within a sixteenth of a turn of one is left out.+ let total = TAU * turns;+ let mut breaks = vec![0.0];+ breaks.extend(m.angles.iter().copied().filter(|&a| a > 0.0 && a < total));+ let mut half = 0.5 * TAU;+ while cylinders && half < total - TAU / 16.0 {+ if !m.angles.iter().any(|a| (a - half).abs() < TAU / 16.0) {+ breaks.push(half);+ }+ half += 0.5 * TAU;+ }+ breaks.push(total);+ breaks.sort_by(f64::total_cmp);+ let rise = m.pitch.abs() / TAU;+ let mut h = (TAU / 8.0).min((tolerance / (0.008 * rise)).cbrt());+ // (bounded: a span this narrow would need more than SMLIB_SCREW_MAX_STATIONS)+ let mut guard = 0;+ while rise * lift_error(0.5 * h) > tolerance && guard < 10_000 {+ h *= 0.99;+ guard += 1;+ }+ let mut pieces = Vec::with_capacity(breaks.len());+ let mut spans = 0.0;+ for pair in breaks.windows(2) {+ let &[from, to] = pair else { continue };+ // Where the offset changes, its spans are narrower still.+ let rate = (m.offset(to) - m.offset(from)).abs() / (to - from);+ let mut piece = h;+ while rise * lift_error(0.5 * piece) + rate * piece * offset_error(0.5 * piece) > tolerance && piece > 1e-4 {+ piece *= 0.99;+ }+ let n = ((to - from) / piece).ceil();+ spans += n;+ if !(spans <= SCREW_MAX_STATIONS) || !(n >= 1.0) {+ return Ok(Err(Error::Argument));+ }+ pieces.push(Stations::new(from, to, n as usize));+ }+ let mut b = new_brep(k, USE_DEFAULT, USE_DEFAULT)?;+ for st in &pieces {+ for (i, (c, wall)) in curves.iter().zip(&walls).enumerate() {+ let r = radius.get(i).copied().unwrap_or(0.0);+ if r > 0.0 && m.offset(st.first()) == m.offset(st.last()) {+ let (a, e) = ends(k, c)?;+ if let Err(err) = cylinder_piece(k, &mut b, &m, a, e, r + m.offset(st.first()), st)? {+ return Ok(Err(err));+ }+ continue;+ }+ let surface = match screw_wall(&m, wall, st) {+ Ok(s) => s,+ Err(err) => return Ok(Err(err)),+ };+ let domain = surface.natural_uv_domain_with_nurb(k)?;+ if let Err(err) = build_faces(&mut b, |b, fenv| create_face_from_surface(k, b, Some(surface), &domain, fenv)) {+ return Ok(Err(status(err)));+ }+ }+ }+ // The caps: the profile where the motion starts and where it ends, placed exactly.+ for a in [0.0, total] {+ let placed: Vec<Profile> = profile.iter().map(|c| screw_placed(&m, c, a)).collect();+ let cap = match parse(k, &placed) {+ Ok(c) => c,+ Err(e) => return Ok(Err(e)),+ };+ let (region, tol) = (b.infinite_region(), b.tolerance());+ if let Err(err) = build_faces(&mut b, |b, fenv| create_planar_faces_with_3d_curves(k, b, region, &cap, tol, fenv)) {+ return Ok(Err(status(err)));+ }+ }+ if let Err(e) = stitch_and_orient(k, &mut b, &StitchAndOrientOptions::default()) {+ return Ok(Err(status(e)));+ }+ b.refresh_cached_topology();+ finish(b, true)+}++/// `smlib_screw_sweep` and `smlib_screw_sweep_radial` (`law`: the radial offset law, as+/// (turn, offset) pairs).+pub(crate) fn screw_sweep(+ profile: &[Profile],+ origin: [f64; 3],+ axis: [f64; 3],+ pitch: f64,+ turns: f64,+ law: Option<&[(f64, f64)]>,+ tolerance: f64,+) -> Result<Body> {+ if !screw_ok(origin, pitch, turns, tolerance) {+ return Err(Error::Argument);+ }+ if let Some(law) = law {+ if law.is_empty() || law.len() > SCREW_MAX_LAW || !law.iter().all(|(t, o)| t.is_finite() && o.is_finite()) {+ return Err(Error::Argument);+ }+ for (i, (t, o)) in law.iter().enumerate() {+ let ascending = i == 0 || law.get(i - 1).is_some_and(|(p, _)| t > p);+ if !(*t >= 0.0 && *t <= turns) || !ascending || !(o.abs() < MAX_COORD) {+ return Err(Error::Argument);+ }+ }+ }+ let call = if law.is_some() { "smlib_screw_sweep_radial" } else { "smlib_screw_sweep" };+ making(call, |k| {+ let Some(axis) = unit(axis) else { return Ok(Err(Error::Argument)) };+ let law = law.unwrap_or_default();+ let m = Screw {+ o: v3(origin),+ k: axis,+ e: Vec3::new(0.0, 0.0, 0.0),+ pitch,+ angles: law.iter().map(|(t, _)| TAU * t).collect(),+ offsets: law.iter().map(|(_, o)| *o).collect(),+ };+ screw(k, profile, m, turns, tolerance)+ })+}++/// `put_curve`: `c` as the NURBS it is, with its interval; [`Error::Unsupported`] for a curve that+/// is no B-spline or whose knots are not clamped.+fn put_curve(c: &Curve) -> solidcore::Result<Out<(Profile, [f64; 2])>> {+ let Some(b) = bspline(c)? else { return Ok(Err(Error::Unsupported)) };+ let can = b.canonical()?;+ let degree = can.degree;+ let count = can.control_points.len();+ let mut knots = Vec::with_capacity(count + degree + 1);+ for (&u, &m) in can.knots.iter().zip(&can.knot_multiplicities) {+ knots.extend(std::iter::repeat_n(u, m));+ }+ let clamped = can.knot_multiplicities.first().is_some_and(|&m| m > degree) && can.knot_multiplicities.last().is_some_and(|&m| m > degree);+ if !(1..=ffi::sweeps::CURVE_MAX_DEGREE).contains(°ree)+ || count < degree + 1+ || count > ffi::sweeps::CURVE_MAX_POINTS+ || knots.len() != count + degree + 1+ || !clamped+ {+ return Ok(Err(Error::Unsupported));+ }+ let points = can.control_points.iter().enumerate().map(|(i, p)| [p.x, p.y, p.z, can.weights.get(i).copied().unwrap_or(1.0)]).collect();+ let ivl = c.natural_interval();+ Ok(Ok((Profile::Nurbs { degree, points, knots }, [ivl.min(), ivl.max()])))+}++/// The pick tolerance and the curve tolerance of `smlib_project_curves` and `smlib_face_section`.+fn tolerances_ok(pick: f64, tolerance: f64) -> bool {+ pick.is_finite() && pick > 0.0 && pick < 1e6 && tolerance.is_finite() && (1e-9..1e3).contains(&tolerance)+}++/// The face of `b` nearest `point` (`smlib_pick::pick_faces` of one point).+fn picked_face(k: &mut Kernel, b: &mut Brep, point: [f64; 3], tol: f64) -> solidcore::Result<Out<FaceId>> {+ Ok(match pick_faces(k, b, &[point], tol)? {+ Ok(f) => f.first().copied().ok_or(Error::NoMatch { point: 0 }),+ Err(m) => Err(face_miss(m)),+ })+}++/// `smlib_project_curves`: `curves` projected along `direction` onto the face nearest+/// `face_point` (`SmBrep::CreateParallelProjectionCurves` on that face), as NURBS with their+/// intervals; none is [`Error::Empty`].+pub(crate) fn project_curves(+ body: &Body,+ face_point: [f64; 3],+ pick_tolerance: f64,+ curves: &[Profile],+ direction: [f64; 3],+ tolerance: f64,+) -> Result<Vec<(Profile, [f64; 2])>> {+ if !face_point.iter().chain(&direction).all(|x| x.is_finite()) || !tolerances_ok(pick_tolerance, tolerance) {+ return Err(Error::Argument);+ }+ let len = v3(direction).length();+ if !(len > 1e-12) {+ return Err(Error::Argument);+ }+ with_body("smlib_project_curves", body, |k, b| {+ let given = match parse(k, curves) {+ Ok(c) => c,+ Err(e) => return Ok(Err(e)),+ };+ let face = match picked_face(k, b, face_point, pick_tolerance)? {+ Ok(f) => f,+ Err(e) => return Ok(Err(e)),+ };+ let dir = v3(direction) * (1.0 / len);+ let faces = [face];+ let opts = ParallelProjectionOptions {+ approx_tol_3d: Some(tolerance),+ subset_faces: Some(&faces),+ want_3d: true,+ ..ParallelProjectionOptions::default()+ };+ let mut out = Vec::new();+ for c in &given {+ // curve->GetRootCurve(): a line, an arc and a B-spline are their own root, and+ // go in as themselves+ if !matches!(c.kind(), CurveKind::BSpline(_) | CurveKind::Line(_) | CurveKind::Ellipse(_)) {+ return Ok(Err(Error::Argument));+ }+ let made = match create_parallel_projection_curves(k, b, c, dir, &opts) {+ Ok(m) => m.curves_3d.unwrap_or_default(),+ Err(e) => return Ok(Err(status(e))),+ };+ for m in &made {+ match put_curve(m)? {+ Ok(x) => out.push(x),+ Err(e) => return Ok(Err(e)),+ }+ }+ }+ Ok(if out.is_empty() { Err(Error::Empty) } else { Ok(out) })+ })?+}++/// `smlib_face_section`: the section of the face nearest `face_point` by the plane through+/// `plane_point` square to `plane_normal` (`SmBrep::CreatePlanarSectionCurves` over the whole+/// B-rep, keeping the curves of the picked face), as NURBS with their intervals; none is+/// [`Error::Empty`].+pub(crate) fn face_section(+ body: &Body,+ face_point: [f64; 3],+ pick_tolerance: f64,+ plane_point: [f64; 3],+ plane_normal: [f64; 3],+ tolerance: f64,+) -> Result<Vec<(Profile, [f64; 2])>> {+ if !face_point.iter().chain(&plane_point).chain(&plane_normal).all(|x| x.is_finite()) || !tolerances_ok(pick_tolerance, tolerance) {+ return Err(Error::Argument);+ }+ let Some(normal) = unit(plane_normal) else { return Err(Error::Argument) };+ with_body("smlib_face_section", body, |k, b| {+ let face = match picked_face(k, b, face_point, pick_tolerance)? {+ Ok(f) => f,+ Err(e) => return Ok(Err(e)),+ };+ // UV curves are asked for, so the classify is forced: an analytic face's intersector+ // makes none, and without it the trim drops the whole section (SmBrep.h documents the+ // flag for this). The capi leaves it FALSE, so the C++ kernel answers Empty on planes,+ // cylinders, cones and spheres (solidcore#1769).+ let opts = PlanarSectionOptions {+ approx_tol_3d: Some(tolerance),+ outputs: SectionOutputs { curves_3d: true, uv_curves: true, faces: true },+ force_uv_classify: true,+ ..PlanarSectionOptions::default()+ };+ let made = match create_planar_section_curves(k, b, v3(plane_point), normal, &opts) {+ Ok(m) => m,+ Err(e) => return Ok(Err(status(e))),+ };+ let curves = made.curves_3d.unwrap_or_default();+ let faces = made.faces.unwrap_or_default();+ // (each curve's face: without one apiece the picked face's curves are not known)+ if faces.len() != curves.len() {+ return Ok(Err(Error::Unsupported));+ }+ let mut out = Vec::new();+ for (c, &f) in curves.iter().zip(&faces) {+ if f == face {+ match put_curve(c)? {+ Ok(x) => out.push(x),+ Err(e) => return Ok(Err(e)),+ }+ }+ }+ Ok(if out.is_empty() { Err(Error::Empty) } else { Ok(out) })+ })?+}diff --git a/crates/smlib/src/core/sweep_tests.rs b/crates/smlib/src/core/sweep_tests.rsnew file mode 100644index 0000000000..257ee4a182--- /dev/null+++ b/crates/smlib/src/core/sweep_tests.rs@@ -0,0 +1,768 @@+//! Extrusions, revolutions, sweeps, lofts and planar faces on solidcore, against closed forms:+//! every result exports to a record that validates. With SMLib built, the same case on the C+++//! kernel gives the same volume (or, for a sheet, area), counts and faces by surface kind, or the+//! same error (parity only: the expected values are the analytic ones).+//!+//! The profiles are built straight into solidcore curves from the curve lists.++use std::collections::BTreeMap;+use std::f64::consts::{FRAC_PI_2, PI, TAU};+use std::sync::mpsc;+use std::time::Duration;++use super::sweep::{extrude, face_section, loft, loft_to_point, planar_faces, project_curves, revolve, screw_sweep, sweep_placed, sweep_stations};+use super::{Body, area, bounds, counts, make_box, make_cylinder, to_arrays, volume};+use crate::Error;+use crate::export::native;+use crate::sweeps::{Affine, CornerRefusal, Curve, DraftCorner, Ends, SweepFrame};++/// A case longer than this is a hang.+const TIMEOUT: Duration = Duration::from_secs(300);++const Z: [f64; 3] = [0.0, 0.0, 1.0];++fn line(a: [f64; 3], b: [f64; 3]) -> Curve {+ Curve::Line { start: a, end: b }+}++/// The closed polygon through `pts`.+fn polygon(pts: &[[f64; 3]]) -> Vec<Curve> {+ (0..pts.len()).map(|i| line(pts[i], pts[(i + 1) % pts.len()])).collect()+}++/// The square of side `s` from `(x, y)` in the plane z = `z`.+fn square(x: f64, y: f64, s: f64, z: f64) -> Vec<Curve> {+ polygon(&[[x, y, z], [x + s, y, z], [x + s, y + s, z], [x, y + s, z]])+}++/// The circle of `radius` about `axis` through `center`, from `reference`.+fn circle(center: [f64; 3], axis: [f64; 3], reference: [f64; 3], radius: f64) -> Curve {+ Curve::Arc { center, axis, reference, radius, start: 0.0, end: TAU }+}++/// An arc of radius 5 about the z axis from `reference`, from `start` to `end`.+fn arc5(reference: [f64; 3], start: f64, end: f64) -> Curve {+ Curve::Arc { center: [0.0; 3], axis: Z, reference, radius: 5.0, start, end }+}++/// The circle of radius 5 about the z axis as two half arcs in one frame.+fn halves() -> Vec<Curve> {+ vec![arc5([1.0, 0.0, 0.0], 0.0, PI), arc5([1.0, 0.0, 0.0], PI, TAU)]+}++/// The circle of radius 5 about the z axis as a quarter from +x and three quarters from +y.+fn two_frames() -> Vec<Curve> {+ vec![arc5([1.0, 0.0, 0.0], 0.0, FRAC_PI_2), arc5([0.0, 1.0, 0.0], 0.0, 3.0 * FRAC_PI_2)]+}++/// The upper half disc of radius 5 about the z axis, its arc in two quarters.+fn half_disc() -> Vec<Curve> {+ vec![arc5([1.0, 0.0, 0.0], 0.0, FRAC_PI_2), arc5([1.0, 0.0, 0.0], FRAC_PI_2, PI), line([-5.0, 0.0, 0.0], [5.0, 0.0, 0.0])]+}++/// The rectangle from x = 5 to 8 and z = 0 to 4 in the plane y = 0: area 12, centroid at x 6.5.+fn ring_section() -> Vec<Curve> {+ polygon(&[[5.0, 0.0, 0.0], [8.0, 0.0, 0.0], [8.0, 0.0, 4.0], [5.0, 0.0, 4.0]])+}++fn translate(t: [f64; 3]) -> Affine {+ Affine { m: [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], t }+}++fn scale_up(s: f64, z: f64) -> Affine {+ Affine { m: [[s, 0.0, 0.0], [0.0, s, 0.0], [0.0, 0.0, 1.0]], t: [0.0, 0.0, z] }+}++#[derive(Clone, Debug)]+enum Op {+ PlanarFaces(Vec<Curve>),+ Extrude(Vec<Curve>, [f64; 3], f64, f64, DraftCorner, bool),+ Revolve(Vec<Curve>, [f64; 3], [f64; 3], f64, bool),+ Sweep(Vec<Curve>, Vec<Curve>, SweepFrame, bool),+ Loft(Vec<Vec<Curve>>, u32, bool),+ LoftToPoint(Vec<Curve>, [f64; 3]),+ Stations(Vec<Curve>, Vec<Affine>, Ends),+ Screw(Vec<Curve>, [f64; 3], [f64; 3], f64, f64, f64),+ /// A screw sweep with a radial law.+ ScrewRadial(Vec<Curve>, [f64; 3], [f64; 3], f64, f64, Vec<(f64, f64)>, f64),+}++/// What a case must give.+#[derive(Clone, Debug)]+enum Expect {+ /// A solid of this volume (relative 1e-9).+ Volume(f64),+ /// A solid of this volume within this relative error (walls approximated within a tolerance).+ About(f64, f64),+ /// A sheet of this area (relative 1e-9).+ Sheet(f64),+ /// A drafted corner refused for this reason, wherever.+ Corner(CornerRefusal),+}++struct Case {+ op: Op,+ expect: Expect,+}++/// The frustum of a pyramid or cone: h/3 (A1 + A2 + sqrt(A1 A2)).+fn frustum(a1: f64, a2: f64, h: f64) -> f64 {+ h / 3.0 * (a1 + a2 + (a1 * a2).sqrt())+}++fn case(name: &str) -> Case {+ let c = |op, expect| Case { op, expect };+ let rect = polygon(&[[0.0, 0.0, 0.0], [30.0, 0.0, 0.0], [30.0, 20.0, 0.0], [0.0, 20.0, 0.0]]);+ let theta = 5f64.to_radians();+ let disc = || vec![circle([0.0; 3], Z, [1.0, 0.0, 0.0], 5.0)];+ match name {+ // A square of 10 with a hole of radius 2: 100 - 4π.+ "planar_faces_with_a_hole" => {+ let mut loops = square(0.0, 0.0, 10.0, 0.0);+ loops.push(circle([5.0, 5.0, 0.0], Z, [1.0, 0.0, 0.0], 2.0));+ c(Op::PlanarFaces(loops), Expect::Sheet(100.0 - 4.0 * PI))+ }+ // V = A h.+ "extrude_rectangle" => c(Op::Extrude(rect, Z, 10.0, 0.0, DraftCorner::default(), true), Expect::Volume(6000.0)),+ // V = π r² h.+ "extrude_circle" => c(Op::Extrude(disc(), Z, 10.0, 0.0, DraftCorner::default(), true), Expect::Volume(250.0 * PI)),+ // A circle drawn in two halves (split where another sketch curve ends on it), the+ // pieces in the circle's own frame: one wall, as the whole circle sweeps (smlib 7dee48f).+ "extrude_circle_in_two_halves" => c(Op::Extrude(halves(), Z, 10.0, 0.0, DraftCorner::default(), true), Expect::Volume(250.0 * PI)),+ // The same circle as a quarter and three quarters each in its own frame: one wall still,+ // its seam in the middle of the longer piece.+ "extrude_circle_in_two_frames" => c(Op::Extrude(two_frames(), Z, 10.0, 0.0, DraftCorner::default(), true), Expect::Volume(250.0 * PI)),+ // A half disc whose arc is drawn in two quarters, closed by its diameter: the quarters+ // sweep one wall. V = π r² h / 2.+ "extrude_half_disc_split_arc" => c(Op::Extrude(half_disc(), Z, 10.0, 0.0, DraftCorner::default(), true), Expect::Volume(125.0 * PI)),+ // Leaning in by θ, the walls' offsets overlap at the corners and are trimmed where they+ // cross, under every rule: the frustum from side 20 to 20 - 2 h tanθ.+ "extrude_square_drafted_round" => {+ let top = 20.0 - 2.0 * 10.0 * theta.tan();+ c(Op::Extrude(square(0.0, 0.0, 20.0, 0.0), Z, 10.0, theta, DraftCorner::Round, true), Expect::Volume(frustum(400.0, top * top, 10.0)))+ }+ "extrude_square_drafted_curvature" => {+ let top = 20.0 - 2.0 * 10.0 * theta.tan();+ c(Op::Extrude(square(0.0, 0.0, 20.0, 0.0), Z, 10.0, theta, DraftCorner::Curvature, true), Expect::Volume(frustum(400.0, top * top, 10.0)))+ }+ // No corner: the cone frustum from radius 5 to 5 - h tanθ.+ "extrude_circle_drafted" => {+ let r2 = 5.0 - 10.0 * theta.tan();+ c(Op::Extrude(disc(), Z, 10.0, theta, DraftCorner::default(), true), Expect::Volume(frustum(PI * 25.0, PI * r2 * r2, 10.0)))+ }+ // A strip 2 wide leaning in 10° over 10: the long walls meet across the short ones+ // (10 tan 10° > 1) before the far end.+ "extrude_draft_wall_closes" => c(+ Op::Extrude(+ polygon(&[[0.0, 0.0, 0.0], [20.0, 0.0, 0.0], [20.0, 2.0, 0.0], [0.0, 2.0, 0.0]]),+ Z,+ 10.0,+ 10f64.to_radians(),+ DraftCorner::Curvature,+ true,+ ),+ Expect::Corner(CornerRefusal::WallCloses),+ ),+ // Pappus: A · θ x̄ = 12 · θ · 6.5.+ "revolve_rectangle_full" => c(Op::Revolve(ring_section(), [0.0; 3], Z, TAU, true), Expect::Volume(12.0 * TAU * 6.5)),+ "revolve_rectangle_quarter" => c(Op::Revolve(ring_section(), [0.0; 3], Z, FRAC_PI_2, true), Expect::Volume(12.0 * FRAC_PI_2 * 6.5)),+ // π r² L, along two lines end to end.+ "sweep_circle_straight" => c(+ Op::Sweep(+ vec![circle([0.0; 3], Z, [1.0, 0.0, 0.0], 2.0)],+ vec![line([0.0; 3], [0.0, 0.0, 6.0]), line([0.0, 0.0, 6.0], [0.0, 0.0, 10.0])],+ SweepFrame::Follow,+ true,+ ),+ Expect::Volume(PI * 4.0 * 10.0),+ ),+ // A quarter of a torus: π r² · R θ.+ "sweep_circle_along_an_arc" => c(+ Op::Sweep(+ vec![circle([10.0, 0.0, 0.0], [0.0, 1.0, 0.0], [1.0, 0.0, 0.0], 1.0)],+ vec![Curve::Arc { center: [0.0; 3], axis: Z, reference: [1.0, 0.0, 0.0], radius: 10.0, start: 0.0, end: FRAC_PI_2 }],+ SweepFrame::Follow,+ true,+ ),+ Expect::Volume(PI * 10.0 * FRAC_PI_2),+ ),+ // A bent path (a line, then a quarter arc) needs the curve sweep: π r² times the path's+ // length, 10 + 10 π/2, within the walls' fit.+ "sweep_along_a_bent_path" => c(+ Op::Sweep(+ vec![circle([0.0; 3], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], 1.0)],+ vec![+ line([0.0; 3], [10.0, 0.0, 0.0]),+ Curve::Arc { center: [10.0, 10.0, 0.0], axis: Z, reference: [0.0, -1.0, 0.0], radius: 10.0, start: 0.0, end: FRAC_PI_2 },+ ],+ SweepFrame::Follow,+ true,+ ),+ Expect::About(PI * (10.0 + 10.0 * FRAC_PI_2), 1e-4),+ ),+ // A 4 x 3 rectangle round a closed 60 x 40 rounded rectangle (corner radius 8), from the+ // middle of its bottom line: no caps, the walls closing on each other. Pappus: A L, with+ // A = 12 and L = 2 (44 + 24) + 4 (π/2) 8.+ "sweep_round_a_closed_path" => {+ let arc = |c: [f64; 3], r: [f64; 3]| Curve::Arc { center: c, axis: Z, reference: r, radius: 8.0, start: 0.0, end: FRAC_PI_2 };+ let path = vec![+ line([0.0, -20.0, 0.0], [22.0, -20.0, 0.0]),+ arc([22.0, -12.0, 0.0], [0.0, -1.0, 0.0]),+ line([30.0, -12.0, 0.0], [30.0, 12.0, 0.0]),+ arc([22.0, 12.0, 0.0], [1.0, 0.0, 0.0]),+ line([22.0, 20.0, 0.0], [-22.0, 20.0, 0.0]),+ arc([-22.0, 12.0, 0.0], [0.0, 1.0, 0.0]),+ line([-30.0, 12.0, 0.0], [-30.0, -12.0, 0.0]),+ arc([-22.0, -12.0, 0.0], [-1.0, 0.0, 0.0]),+ line([-22.0, -20.0, 0.0], [0.0, -20.0, 0.0]),+ ];+ c(+ Op::Sweep(polygon(&[[0.0, -22.0, -1.5], [0.0, -18.0, -1.5], [0.0, -18.0, 1.5], [0.0, -22.0, 1.5]]), path, SweepFrame::Follow, true),+ Expect::About(12.0 * (2.0 * (44.0 + 24.0) + 16.0 * PI), 1e-4),+ )+ }+ // The frustum of a square pyramid: side 20 to 10 over 10.+ "loft_two_squares" => {+ c(Op::Loft(vec![square(0.0, 0.0, 20.0, 0.0), square(5.0, 5.0, 10.0, 10.0)], 1, true), Expect::Volume(frustum(400.0, 100.0, 10.0)))+ }+ // The cone frustum: radius 5 to 3 over 10.+ "loft_two_circles" => c(+ Op::Loft(vec![disc(), vec![circle([0.0, 0.0, 10.0], Z, [1.0, 0.0, 0.0], 3.0)]], 1, true),+ Expect::Volume(frustum(25.0 * PI, 9.0 * PI, 10.0)),+ ),+ // A h / 3.+ "loft_to_point_pyramid" => c(Op::LoftToPoint(square(0.0, 0.0, 10.0, 0.0), [5.0, 5.0, 6.0]), Expect::Volume(200.0)),+ // A square of 2 carried up 10: 40.+ "sweep_stations_prism" => c(+ Op::Stations(+ square(-1.0, -1.0, 2.0, 0.0),+ vec![translate([0.0; 3]), translate([0.0, 0.0, 5.0]), translate([0.0, 0.0, 10.0])],+ Ends::Capped,+ ),+ Expect::Volume(40.0),+ ),+ // Scaled by s = 1 + z/10 on the way: ∫ (2 s)² dz = 4 · 10 · (2³ - 1) / 3.+ "sweep_stations_scaled" => c(+ Op::Stations(square(-1.0, -1.0, 2.0, 0.0), vec![scale_up(1.0, 0.0), scale_up(1.5, 5.0), scale_up(2.0, 10.0)], Ends::Capped),+ Expect::Volume(4.0 * 10.0 * 7.0 / 3.0),+ ),+ // A square thread 1 x 1 from radius 5 to 6, pitch 2, two turns: Pappus along the screw+ // motion (its rise lies in the profile's plane), A · 2π x̄ · turns, the walls within the+ // tolerance of the screw surfaces.+ "screw_sweep_square_thread" => c(+ Op::Screw(polygon(&[[5.0, 0.0, 0.0], [6.0, 0.0, 0.0], [6.0, 0.0, 1.0], [5.0, 0.0, 1.0]]), [0.0; 3], Z, 2.0, 2.0, 1e-5),+ Expect::About(TAU * 5.5 * 2.0, 1e-5),+ ),+ // The same thread moved out by 0 to 1 over its two turns, linearly: Pappus with the+ // centroid at 5.5 + t/2, A · 2π · turns · (5.5 + 1/2).+ "screw_sweep_radial_taper" => c(+ Op::ScrewRadial(+ polygon(&[[5.0, 0.0, 0.0], [6.0, 0.0, 0.0], [6.0, 0.0, 1.0], [5.0, 0.0, 1.0]]),+ [0.0; 3],+ Z,+ 2.0,+ 2.0,+ vec![(0.0, 0.0), (2.0, 1.0)],+ 1e-5,+ ),+ Expect::About(TAU * 2.0 * 6.0, 1e-5),+ ),+ _ => panic!("{name}"),+ }+}++fn rel(a: f64, b: f64) -> f64 {+ (a - b).abs() / b.abs()+}++#[derive(Debug, PartialEq)]+struct Measured {+ /// The volume of a solid, the area of a sheet.+ size: f64,+ counts: [usize; 3],+ kinds: BTreeMap<String, usize>,+}++fn kinds(rec: &solidcraft_geom::brep::Brep) -> BTreeMap<String, usize> {+ let mut out = BTreeMap::new();+ for f in &rec.faces {+ let v = serde_json::to_value(&f.surface).unwrap();+ *out.entry(v["kind"].as_str().unwrap_or("?").to_owned()).or_default() += 1;+ }+ out+}++fn on_core(op: &Op) -> crate::Result<Body> {+ match op {+ Op::PlanarFaces(l) => planar_faces(l),+ Op::Extrude(p, d, dist, draft, corner, cap) => extrude(p, *d, *dist, *draft, *corner, *cap),+ Op::Revolve(p, o, a, angle, cap) => revolve(p, *o, *a, *angle, *cap),+ Op::Sweep(p, path, frame, cap) => sweep_placed(p, path, *frame, *cap).map(|(b, _)| b),+ Op::Loft(s, d, cap) => loft(s, *d, *cap),+ Op::LoftToPoint(s, apex) => loft_to_point(s, *apex),+ Op::Stations(p, s, e) => sweep_stations(p, s, *e),+ Op::Screw(p, o, a, pitch, turns, tol) => screw_sweep(p, *o, *a, *pitch, *turns, None, *tol),+ Op::ScrewRadial(p, o, a, pitch, turns, law, tol) => screw_sweep(p, *o, *a, *pitch, *turns, Some(law), *tol),+ }+}++/// Runs `f` on its own thread: a hang fails the test instead of stopping the run.+fn timed<T: Send + 'static>(name: &str, f: impl FnOnce() -> T + Send + 'static) -> T {+ let (tx, rx) = mpsc::channel();+ let worker = std::thread::spawn(move || {+ let _ = tx.send(f());+ });+ match rx.recv_timeout(TIMEOUT) {+ Ok(v) => v,+ Err(mpsc::RecvTimeoutError::Disconnected) => match worker.join() {+ Err(p) => std::panic::resume_unwind(p),+ Ok(()) => panic!("{name}: no result"),+ },+ Err(mpsc::RecvTimeoutError::Timeout) => panic!("{name}: solidcore hung (no result after {TIMEOUT:?})"),+ }+}++type Got = std::result::Result<Measured, Error>;++/// Checks a kernel's result against the case's closed form; what it measured, or its error.+fn judge(name: &str, who: &str, expect: &Expect, got: Got) -> Got {+ match (expect, &got) {+ (Expect::Corner(why), Err(g)) => {+ assert!(+ matches!(g, Error::Corner { why: w, at } if w == why && at.iter().all(|x| x.is_finite())),+ "{name}: {who} failed otherwise: {g:?}"+ )+ }+ (Expect::Corner(_), Ok(m)) => panic!("{name}: {who} gave {m:?}, expected {expect:?}"),+ (_, Err(g)) => panic!("{name}: {who} failed: {g}"),+ (Expect::Volume(v) | Expect::Sheet(v), Ok(m)) => assert!(rel(m.size, *v) < 1e-9, "{name}: {who} {} vs analytic {v}", m.size),+ (Expect::About(v, within), Ok(m)) => assert!(rel(m.size, *v) < *within, "{name}: {who} {} vs analytic {v}", m.size),+ }+ got+}++fn solidcore_case(name: &'static str) -> Got {+ timed(name, move || {+ let c = case(name);+ let sheet = matches!(c.expect, Expect::Sheet(_));+ let got = on_core(&c.op).map(|body| {+ let size = if sheet { area(&body, 1e-8) } else { volume(&body, 1e-8) }.unwrap_or_else(|e| panic!("{name}: size: {e}"));+ let n = counts(&body).unwrap();+ let (rec, _) = native(&to_arrays(&body).unwrap()).unwrap_or_else(|e| panic!("{name}: record: {e:?}"));+ rec.validate().unwrap_or_else(|e| panic!("{name}: record: {e}"));+ bounds(&body).unwrap();+ Measured { size, counts: n, kinds: kinds(&rec) }+ });+ judge(name, "solidcore", &c.expect, got)+ })+}++/// The case on the C++ kernel, through the public sweeps forced onto it on this thread.+#[cfg(feature = "native")]+fn cpp_case(name: &str) -> Got {+ use crate::{Brep, ffi};+ crate::sweeps::ON_CPP.with(|c| c.set(true));+ let c = case(name);+ let r = match &c.op {+ Op::PlanarFaces(l) => Brep::planar_faces(l),+ Op::Extrude(p, d, dist, draft, corner, cap) => Brep::extrude(p, *d, *dist, *draft, *corner, *cap),+ Op::Revolve(p, o, a, angle, cap) => Brep::revolve(p, *o, *a, *angle, *cap),+ Op::Sweep(p, path, frame, cap) => Brep::sweep(p, path, *frame, *cap),+ Op::Loft(s, d, cap) => Brep::loft(s, *d, *cap),+ Op::LoftToPoint(s, apex) => Brep::loft_to_point(s, *apex),+ Op::Stations(p, s, e) => Brep::sweep_stations(p, s, *e),+ Op::Screw(p, o, a, pitch, turns, tol) => Brep::screw_sweep(p, *o, *a, *pitch, *turns, *tol),+ Op::ScrewRadial(p, o, a, pitch, turns, law, tol) => Brep::screw_sweep_radial(p, *o, *a, *pitch, *turns, law, *tol),+ };+ crate::sweeps::ON_CPP.with(|c| c.set(false));+ let sheet = matches!(c.expect, Expect::Sheet(_));+ let got = r.map(|b| {+ let h = b.cpp().unwrap();+ let size = if sheet { ffi::measure::area(h, 1e-8) } else { ffi::volume(h, 1e-8) }.unwrap();+ let n = ffi::counts(h).unwrap().map(|x| usize::try_from(x).unwrap());+ let (rec, _) = native(&b.cpp_arrays().unwrap()).unwrap();+ rec.validate().unwrap();+ Measured { size, counts: n, kinds: kinds(&rec) }+ });+ judge(name, "C++", &c.expect, got)+}++/// solidcore and C++ agree: volume (area) within 1e-9, the same counts and faces by kind, or the+/// same error.+#[cfg(feature = "native")]+fn parity(name: &'static str) {+ let cpp = cpp_case(name);+ let ours = solidcore_case(name);+ match (ours, cpp) {+ (Ok(a), Ok(b)) => {+ assert!(rel(a.size, b.size) < 1e-9, "{name}: solidcore {} vs C++ {}", a.size, b.size);+ assert_eq!(a.counts, b.counts, "{name}: face, edge, vertex counts (solidcore vs C++)");+ assert_eq!(a.kinds, b.kinds, "{name}: faces by surface kind (solidcore vs C++)");+ }+ (a, b) => assert_eq!(a.err(), b.err(), "{name}: errors (solidcore vs C++)"),+ }+}++macro_rules! cases {+ ($($m:ident $([$pign:meta])? $(: $ign:meta)?),* $(,)?) => {$(+ mod $m {+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_closed_form() {+ let _ = super::solidcore_case(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ $(#[$ign])?+ $(#[$pign])?+ fn solidcore_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ super::parity(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ fn the_cpp_kernel_matches_the_closed_form() {+ let _cpp = crate::route::on_cpp();+ let _ = super::cpp_case(stringify!($m));+ }+ }+ )*};+}++// Cases marked `[ignore = …]` match the closed form on solidcore but not the C++ kernel's+// numbers; `: ignore = …` ones fail on solidcore.+cases!(+ planar_faces_with_a_hole,+ extrude_rectangle,+ extrude_circle,+ extrude_circle_in_two_halves,+ extrude_circle_in_two_frames,+ extrude_half_disc_split_arc,+ extrude_square_drafted_round,+ extrude_square_drafted_curvature,+ extrude_circle_drafted,+ extrude_draft_wall_closes,+ revolve_rectangle_full,+ revolve_rectangle_quarter,+ sweep_circle_straight,+ sweep_circle_along_an_arc,+ sweep_along_a_bent_path,+ sweep_round_a_closed_path,+ loft_two_squares,+ loft_two_circles,+ loft_to_point_pyramid,+ sweep_stations_prism,+ sweep_stations_scaled,+ screw_sweep_square_thread,+ screw_sweep_radial_taper,+);++/// Arcs of a profile on one circle sweep one wall face (tangency-labs/smlib 7dee48f): a circle+/// in two pieces extrudes to the faces, edges and vertices of the whole circle (two caps and one+/// cylinder: 3 faces, 3 edges with the seam, 2 vertices) and the area 2πr² + 2πrh; a half disc+/// whose arc is in two quarters to its diameter's plane wall and one cylinder (4 faces, 6 edges,+/// 4 vertices) and the area πr² + πrh + 2rh. On solidcore, and with SMLib built on the C++ kernel.+#[test]+fn arcs_on_one_circle_sweep_one_wall() {+ #[cfg(feature = "native")]+ let _cpp = crate::route::on_cpp();+ let cases = [+ ("extrude_circle_in_two_halves", [3, 3, 2], 50.0 * PI + 100.0 * PI, true),+ ("extrude_circle_in_two_frames", [3, 3, 2], 50.0 * PI + 100.0 * PI, true),+ // solidcore sweeps a partial arc, merged or drawn whole, to a surface of extrusion (a+ // rational spline in the record) where the C++ kernel makes a cylinder: one wall still.+ ("extrude_half_disc_split_arc", [4, 6, 4], 25.0 * PI + 50.0 * PI + 100.0, false),+ ];+ let walls = |kinds: &BTreeMap<String, usize>| kinds.iter().filter(|(k, _)| !k.starts_with("plane")).map(|(_, n)| *n).sum::<usize>();+ for (name, want_counts, want_area, cylinder_on_core) in cases {+ let (counts_got, kinds_got, area_got) = timed(name, move || {+ let body = on_core(&case(name).op).unwrap_or_else(|e| panic!("{name}: {e}"));+ let (rec, _) = native(&to_arrays(&body).unwrap()).unwrap();+ (counts(&body).unwrap(), kinds(&rec), area(&body, 1e-8).unwrap())+ });+ assert_eq!(counts_got, want_counts, "{name}: solidcore faces, edges, vertices");+ assert_eq!(walls(&kinds_got), 1, "{name}: solidcore curved walls {kinds_got:?}");+ if cylinder_on_core {+ assert_eq!(kinds_got.get("cylinder"), Some(&1), "{name}: solidcore walls {kinds_got:?}");+ }+ assert!(rel(area_got, want_area) < 1e-9, "{name}: solidcore area {area_got} vs analytic {want_area}");+ #[cfg(feature = "native")]+ {+ use crate::{Brep, ffi};+ crate::sweeps::ON_CPP.with(|c| c.set(true));+ let r = match case(name).op {+ Op::Extrude(p, d, dist, draft, corner, cap) => Brep::extrude(&p, d, dist, draft, corner, cap),+ op => panic!("{name}: {op:?}"),+ };+ crate::sweeps::ON_CPP.with(|c| c.set(false));+ let b = r.unwrap_or_else(|e| panic!("{name}: C++: {e}"));+ let h = b.cpp().unwrap();+ let n = ffi::counts(h).unwrap().map(|x| usize::try_from(x).unwrap());+ let (rec, _) = native(&b.cpp_arrays().unwrap()).unwrap();+ assert_eq!(n, want_counts, "{name}: C++ faces, edges, vertices");+ assert_eq!(walls(&kinds(&rec)), 1, "{name}: C++ curved walls {:?}", kinds(&rec));+ assert_eq!(kinds(&rec).get("cylinder"), Some(&1), "{name}: C++ walls {:?}", kinds(&rec));+ let a = ffi::measure::area(h, 1e-8).unwrap();+ assert!(rel(a, want_area) < 1e-9, "{name}: C++ area {a} vs analytic {want_area}");+ }+ }+}++fn near(a: [f64; 3], b: [f64; 3]) -> bool {+ a.iter().zip(&b).all(|(x, y)| (x - y).abs() < 1e-9)+}++fn same_motion(a: &Affine, b: &Affine) -> bool {+ a.m.iter().zip(&b.m).all(|(x, y)| near(*x, *y)) && near(a.t, b.t)+}++/// The motions of a quarter turn about the z axis: by 0, π/4 and π/2.+fn quarter_turn() -> [Affine; 3] {+ [0.0, FRAC_PI_2 / 2.0, FRAC_PI_2].map(|a: f64| {+ let (c, s) = (a.cos(), a.sin());+ Affine { m: [[c, s, 0.0], [-s, c, 0.0], [0.0, 0.0, 1.0]], t: [0.0; 3] }+ })+}++fn straight_up() -> (Vec<Curve>, Vec<Curve>) {+ (vec![circle([0.0; 3], Z, [1.0, 0.0, 0.0], 2.0)], vec![line([0.0; 3], [0.0, 0.0, 10.0])])+}++fn round_z() -> (Vec<Curve>, Vec<Curve>) {+ (+ vec![circle([10.0, 0.0, 0.0], [0.0, 1.0, 0.0], [1.0, 0.0, 0.0], 1.0)],+ vec![Curve::Arc { center: [0.0; 3], axis: Z, reference: [1.0, 0.0, 0.0], radius: 10.0, start: 0.0, end: FRAC_PI_2 }],+ )+}++fn check_motions(placed: &[Affine; 3], want: &[Affine; 3]) {+ assert!(placed.iter().zip(want).all(|(a, b)| same_motion(a, b)), "{placed:?}, expected {want:?}");+}++/// `sweep_placed`: along a straight path the profile only moves, by none, half and all of the+/// path; along an arc about z it turns with it about the arc's centre, by none, half and all of+/// the arc's angle.+#[test]+fn sweep_placed_reports_the_motions() {+ let (placed, turned) = timed("placed", || {+ let (p, up) = straight_up();+ let (q, arc) = round_z();+ (sweep_placed(&p, &up, SweepFrame::Follow, true).unwrap().1, sweep_placed(&q, &arc, SweepFrame::Follow, true).unwrap().1)+ });+ check_motions(&placed, &[0.0, 5.0, 10.0].map(|z| translate([0.0, 0.0, z])));+ check_motions(&turned, &quarter_turn());+}++/// The same motions on the C++ kernel.+#[cfg(feature = "native")]+#[test]+fn the_cpp_kernel_places_the_profile_alike() {+ let _cpp = crate::route::on_cpp();+ crate::sweeps::ON_CPP.with(|c| c.set(true));+ let (p, up) = straight_up();+ let (q, arc) = round_z();+ let placed = crate::Brep::sweep_placed(&p, &up, SweepFrame::Follow, true).unwrap().1;+ let turned = crate::Brep::sweep_placed(&q, &arc, SweepFrame::Follow, true).unwrap().1;+ crate::sweeps::ON_CPP.with(|c| c.set(false));+ check_motions(&placed, &[0.0, 5.0, 10.0].map(|z| translate([0.0, 0.0, z])));+ check_motions(&turned, &quarter_turn());+}++/// A diagonal 10 above a 10 x 10 x 10 box's top, projected down onto the top: the same diagonal+/// at z = 10.+#[test]+fn project_a_line_onto_a_face() {+ let got = timed("project", || {+ let b = make_box([0.0; 3], [10.0; 3]).unwrap();+ project_curves(&b, [5.0, 5.0, 10.0], 0.01, &[line([1.0, 1.0, 20.0], [9.0, 9.0, 20.0])], [0.0, 0.0, -1.0], 1e-6)+ })+ .unwrap();+ assert_eq!(got.len(), 1, "{got:?}");+ let Some((Curve::Nurbs { points, .. }, _)) = got.first() else { panic!("{got:?}") };+ let (a, b) = (points[0], points[points.len() - 1]);+ let ends = [[a[0], a[1], a[2]], [b[0], b[1], b[2]]];+ let want = [[1.0, 1.0, 10.0], [9.0, 9.0, 10.0]];+ assert!((near(ends[0], want[0]) && near(ends[1], want[1])) || (near(ends[0], want[1]) && near(ends[1], want[0])), "{ends:?}");+}++/// A point of a section curve: the rational B-spline at `u` (de Boor on the weighted points).+fn at(c: &Curve, u: f64) -> [f64; 3] {+ let Curve::Nurbs { degree, points, knots } = c else { panic!("{c:?}") };+ let p = *degree;+ let span = (p..points.len()).rev().find(|&i| knots[i] <= u).unwrap_or(p);+ let mut d: Vec<[f64; 4]> = (0..=p).map(|j| points[span - p + j]).map(|[x, y, z, w]| [x * w, y * w, z * w, w]).collect();+ for r in 1..=p {+ for j in (r..=p).rev() {+ let i = span - p + j;+ let den = knots[i + p + 1 - r] - knots[i];+ let a = if den > 0.0 { (u - knots[i]) / den } else { 0.0 };+ let prev = d[j - 1];+ for (x, q) in d[j].iter_mut().zip(prev) {+ *x = (1.0 - a) * q + a * *x;+ }+ }+ }+ let [x, y, z, w] = d[p];+ [x / w, y / w, z / w]+}++/// `n + 1` points along each section curve over its interval.+fn samples(got: &[(Curve, [f64; 2])], n: usize) -> Vec<Vec<[f64; 3]>> {+ got.iter().map(|(c, [a, b])| (0..=n).map(|i| at(c, a + (b - a) * i as f64 / n as f64)).collect()).collect()+}++/// The length of the section curves, from chords.+fn length(pts: &[Vec<[f64; 3]>]) -> f64 {+ pts.iter().flat_map(|p| p.windows(2)).map(|w| (0..3).map(|i| (w[1][i] - w[0][i]).powi(2)).sum::<f64>().sqrt()).sum()+}++/// A loft from a 10 x 10 square at z = 0 to a 6 x 6 one at z = 10 (degree 1): its front wall+/// runs from y = 0 up to y = 2, so the plane z = 5 cuts it in the line from (9, 1, 5) to+/// (1, 1, 5).+fn square_frustum() -> Vec<Vec<Curve>> {+ vec![square(0.0, 0.0, 10.0, 0.0), square(2.0, 2.0, 6.0, 10.0)]+}++#[test]+fn a_lofted_wall_section_is_the_line_across_it() {+ let got = timed("section", || {+ let b = loft(&square_frustum(), 1, true).unwrap();+ face_section(&b, [5.0, 1.0, 5.0], 0.01, [0.0, 0.0, 5.0], [0.0, 0.0, 1.0], 1e-6)+ })+ .unwrap();+ assert_eq!(got.len(), 1, "{got:?}");+ let p = samples(&got, 8);+ let ends = [p[0][0], p[0][8]];+ let want = [[9.0, 1.0, 5.0], [1.0, 1.0, 5.0]];+ assert!((near(ends[0], want[0]) && near(ends[1], want[1])) || (near(ends[0], want[1]) && near(ends[1], want[0])), "{ends:?}");+ assert!(p[0].iter().all(|q| (q[1] - 1.0).abs() < 1e-9 && (q[2] - 5.0).abs() < 1e-9), "{p:?}");+}++/// The plane z = 3 through the side of a cylinder of radius 5 and height 10 on the xy plane: the+/// circle of radius 5 at z = 3, 2π·5 long.+#[test]+fn a_cylinder_side_section_is_its_circle() {+ let got = timed("section", || {+ let b = make_cylinder([0.0; 3], 5.0, 10.0).unwrap();+ face_section(&b, [5.0, 0.0, 5.0], 0.01, [0.0, 0.0, 3.0], [0.0, 0.0, 1.0], 1e-7)+ })+ .unwrap();+ let p = samples(&got, 2000);+ for q in p.iter().flatten() {+ assert!(((q[0] * q[0] + q[1] * q[1]).sqrt() - 5.0).abs() < 1e-6 && (q[2] - 3.0).abs() < 1e-9, "{q:?}");+ }+ let len = length(&p);+ assert!((len - TAU * 5.0).abs() < 1e-4, "{len} against {}", TAU * 5.0);+}++/// The plane x = 5 through the top of a 10 mm box: the line (5, 0, 10)-(5, 10, 10) across it.+#[test]+fn a_box_top_section_is_the_line_across_it() {+ let got = timed("section", || {+ let b = make_box([0.0; 3], [10.0; 3]).unwrap();+ face_section(&b, [5.0, 5.0, 10.0], 0.01, [5.0, 5.0, 5.0], [1.0, 0.0, 0.0], 1e-7)+ })+ .unwrap();+ let p = samples(&got, 8);+ assert!(p.iter().flatten().all(|q| (q[0] - 5.0).abs() < 1e-9 && (q[2] - 10.0).abs() < 1e-9), "{p:?}");+ let len = length(&p);+ assert!((len - 10.0).abs() < 1e-6, "{len} against 10");+}++/// The same sections on the C++ kernel: the lofted wall's line along the same points. On a box's+/// top and a cylinder's side, whose analytic intersectors make no UV curves, the capi leaves+/// `bForceUVClassify` FALSE and answers [`Error::Empty`] (solidcore#1769), where the port has the+/// section.+#[cfg(feature = "native")]+#[test]+fn the_cpp_kernel_sections_a_face_alike() {+ let _cpp = crate::route::on_cpp();+ use crate::{Brep, ffi};+ type Case = (&'static str, Box<dyn Fn() -> Body>, Brep, [[f64; 3]; 3]);+ let cases: [Case; 3] = [+ (+ "loft",+ Box::new(|| loft(&square_frustum(), 1, true).unwrap()),+ {+ crate::sweeps::ON_CPP.with(|c| c.set(true));+ let b = Brep::loft(&square_frustum(), 1, true).unwrap();+ crate::sweeps::ON_CPP.with(|c| c.set(false));+ b+ },+ [[5.0, 1.0, 5.0], [0.0, 0.0, 5.0], [0.0, 0.0, 1.0]],+ ),+ (+ "box",+ Box::new(|| make_box([0.0; 3], [10.0; 3]).unwrap()),+ ffi::make_box(&[0.0; 3], &[10.0; 3]).map(Brep::made).unwrap(),+ [[5.0, 5.0, 10.0], [5.0, 5.0, 5.0], [1.0, 0.0, 0.0]],+ ),+ (+ "cylinder",+ Box::new(|| make_cylinder([0.0; 3], 5.0, 10.0).unwrap()),+ ffi::make_cylinder(&[0.0; 3], 5.0, 10.0).map(Brep::made).unwrap(),+ [[5.0, 0.0, 5.0], [0.0, 0.0, 3.0], [0.0, 0.0, 1.0]],+ ),+ ];+ for (name, core, cpp, [face, through, n]) in cases {+ crate::sweeps::ON_CPP.with(|c| c.set(true));+ let want = cpp.face_section(face, 0.01, through, n, 1e-6);+ crate::sweeps::ON_CPP.with(|c| c.set(false));+ let got = face_section(&core(), face, 0.01, through, n, 1e-6);+ let (got, want) = match (got, want) {+ (Ok(g), Ok(w)) => (g, w),+ (Ok(g), Err(Error::Empty)) if name != "loft" => {+ assert!(!g.is_empty(), "{name}: the port has the section the capi drops");+ continue;+ }+ (g, w) => panic!("{name}: {:?} against {:?}", g.err(), w.err()),+ };+ assert_eq!(got.len(), want.len(), "{name}: {got:?} against {want:?}");+ let (g, w) = (samples(&got, 64), samples(&want, 64));+ for (a, b) in g.iter().flatten().zip(w.iter().flatten()) {+ assert!(a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-9), "{name}: {a:?} against {b:?}");+ }+ }+}++/// The capi's argument checks, before any kernel call.+#[test]+fn hostile_arguments_are_refused() {+ let sq = square(0.0, 0.0, 1.0, 0.0);+ let d = DraftCorner::default();+ for dist in [0.0, -1.0, f64::NAN, 1e10] {+ assert_eq!(extrude(&sq, Z, dist, 0.0, d, true).err(), Some(Error::Argument), "distance {dist}");+ }+ assert_eq!(extrude(&sq, Z, 1.0, FRAC_PI_2, d, true).err(), Some(Error::Argument), "a right-angled draft");+ assert_eq!(extrude(&sq, [0.0; 3], 1.0, 0.0, d, true).err(), Some(Error::Argument), "no direction");+ assert_eq!(extrude(&[], Z, 1.0, 0.0, d, true).err(), Some(Error::Argument), "no profile");+ assert_eq!(extrude(&[line([0.0; 3], [0.0; 3])], Z, 1.0, 0.0, d, true).err(), Some(Error::Argument), "a point");+ assert_eq!(extrude(&[line([f64::NAN; 3], [1.0; 3])], Z, 1.0, 0.0, d, true).err(), Some(Error::Argument));+ // A drafted profile is one loop, square to the direction.+ assert_eq!(extrude(&sq[..3], Z, 1.0, 0.1, d, true).err(), Some(Error::Argument), "an open profile");+ assert_eq!(extrude(&sq, [1.0, 0.0, 0.0], 1.0, 0.1, d, true).err(), Some(Error::Argument), "along the profile");+ let bad_arc = Curve::Arc { center: [0.0; 3], axis: Z, reference: Z, radius: 1.0, start: 0.0, end: 1.0 };+ assert_eq!(extrude(&[bad_arc], Z, 1.0, 0.0, d, false).err(), Some(Error::Argument), "reference along the axis");+ let bad_nurbs = Curve::Nurbs { degree: 1, points: vec![[0.0; 4], [1.0, 0.0, 0.0, 1.0]], knots: vec![0.0, 0.0, 1.0, 1.0] };+ assert_eq!(extrude(&[bad_nurbs], Z, 1.0, 0.0, d, false).err(), Some(Error::Argument), "a zero weight");+ let unclamped = Curve::Nurbs { degree: 1, points: vec![[0.0, 0.0, 0.0, 1.0], [1.0, 0.0, 0.0, 1.0]], knots: vec![0.0, 0.5, 1.0, 1.0] };+ assert_eq!(extrude(&[unclamped], Z, 1.0, 0.0, d, false).err(), Some(Error::Argument), "unclamped knots");+ assert_eq!(revolve(&sq, [0.0; 3], Z, 0.0, true).err(), Some(Error::Argument), "no angle");+ assert_eq!(revolve(&sq, [0.0; 3], Z, 7.0, true).err(), Some(Error::Argument), "more than a turn");+ assert_eq!(revolve(&sq, [f64::INFINITY; 3], Z, 1.0, true).err(), Some(Error::Argument));+ assert_eq!(loft(std::slice::from_ref(&sq), 1, true).err(), Some(Error::Argument), "one section");+ assert_eq!(loft(&[sq.clone(), sq.clone()], 4, true).err(), Some(Error::Argument), "degree 4");+ assert_eq!(loft_to_point(&sq, [0.5, 0.5, 0.0]).err(), Some(Error::Argument), "apex in the base's plane");+ assert_eq!(loft_to_point(&[circle([0.0; 3], Z, [1.0, 0.0, 0.0], 1.0)], Z).err(), Some(Error::Argument), "not lines");+ let flat = Affine { m: [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 0.0]], t: [0.0; 3] };+ assert_eq!(sweep_stations(&sq, &[translate([0.0; 3]), flat], Ends::Capped).err(), Some(Error::Argument), "a singular map");+ assert_eq!(sweep_stations(&sq, &[translate([0.0; 3])], Ends::Capped).err(), Some(Error::Argument), "one station");+ assert_eq!(screw_sweep(&sq, [0.0; 3], Z, 0.0, 1.0, None, 1e-3).err(), Some(Error::Argument), "no pitch");+ assert_eq!(screw_sweep(&sq, [0.0; 3], Z, 1.0, 300.0, None, 1e-3).err(), Some(Error::Argument), "too many turns");+ assert_eq!(screw_sweep(&sq, [0.0; 3], Z, 1.0, 1.0, Some(&[(0.5, 0.0), (0.2, 0.0)]), 1e-3).err(), Some(Error::Argument), "a law going back");+ assert_eq!(screw_sweep(&sq, [0.0; 3], Z, 1.0, 1.0, Some(&[]), 1e-3).err(), Some(Error::Argument), "an empty law");+ let b = make_box([0.0; 3], [1.0; 3]).unwrap();+ assert_eq!(project_curves(&b, [0.5; 3], 0.01, &sq, [0.0; 3], 1e-6).err(), Some(Error::Argument), "no direction");+ assert_eq!(project_curves(&b, [0.5; 3], 0.0, &sq, Z, 1e-6).err(), Some(Error::Argument), "no pick tolerance");+ assert_eq!(face_section(&b, [0.5; 3], 0.01, [0.5; 3], [0.0; 3], 1e-6).err(), Some(Error::Argument), "no plane normal");+}diff --git a/crates/smlib/src/core/transform.rs b/crates/smlib/src/core/transform.rsnew file mode 100644index 0000000000..2c28340a87--- /dev/null+++ b/crates/smlib/src/core/transform.rs@@ -0,0 +1,32 @@+//! Copies and affine transforms on solidcore: the C API's `smlib_brep_copy` and+//! `smlib_brep_transform`, ported from the fork's `capi/src/smlib_c.cpp`.+//!+//! As there, a transform works on a copy of its body (`SmApiBrepCopy`), which+//! `SmBrep::Transform(double[4][4], bScaleTol)` (solidcore's `transform_matrix`, solidcore#1570)+//! then moves in place, tolerances scaling with the model. The matrix is the capi's: rows 0-2 the+//! images of x, y and z, row 3 the translation (row-vector convention, `p' = p·A + t`); the+//! fourth column is not read.++use super::Body;+use super::blend::{on_copy, status};+use crate::{Error, Result};+use solidcore::topology::brep::mirror::transform_matrix;++/// `smlib_brep_copy`: `SmApiBrepCopy`.+pub(crate) fn copy(body: &Body) -> Result<Body> {+ on_copy("SmApiBrepCopy", body, |_, b| Ok(Ok(b)))+}++/// `smlib_brep_transform`: `SmBrep::Transform(matrix, TRUE)` on a copy of `body`. Every entry of+/// the matrix must be finite (`SMLIB_ERR_ARG`).+pub(crate) fn transform(body: &Body, matrix: &[[f64; 4]; 4]) -> Result<Body> {+ if !matrix.iter().flatten().all(|x| x.is_finite()) {+ return Err(Error::Argument);+ }+ on_copy("SmBrep::Transform", body, |k, mut b| {+ Ok(match transform_matrix(k, &mut b, matrix, true) {+ Ok(()) => Ok(b),+ Err(e) => Err(status(e)),+ })+ })+}diff --git a/crates/smlib/src/core/transform_tests.rs b/crates/smlib/src/core/transform_tests.rsnew file mode 100644index 0000000000..afc373d890--- /dev/null+++ b/crates/smlib/src/core/transform_tests.rs@@ -0,0 +1,328 @@+//! Copies and affine transforms on solidcore, against closed forms: every result keeps its counts,+//! its volume scales by the matrix's |det|, its bounds are the moved box's, and it exports to a+//! record that validates. With SMLib built, the same case on the C++ kernel gives the same+//! volume, counts, bounds and faces by surface kind, or the same error (parity only: the+//! expected values are the analytic ones).++use std::collections::BTreeMap;+use std::f64::consts::PI;++use super::transform::{copy, transform};+use super::{Body, bounds, counts, make_box, make_cylinder, to_arrays, volume};+use crate::Error;+use crate::export::native;++/// The identity, as the capi reads a matrix: rows 0-2 the images of x, y and z, row 3 the move.+const ID: [[f64; 4]; 4] = [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]];++#[derive(Clone, Copy, Debug)]+enum Shape {+ /// A box from its lower corner.+ Box([f64; 3], [f64; 3]),+ /// A cylinder about +Z from its base centre.+ Cylinder([f64; 3], f64, f64),+}++impl Shape {+ fn core(self) -> Body {+ match self {+ Shape::Box(o, s) => make_box(o, s).unwrap(),+ Shape::Cylinder(o, r, h) => make_cylinder(o, r, h).unwrap(),+ }+ }++ fn volume(self) -> f64 {+ match self {+ Shape::Box(_, s) => s[0] * s[1] * s[2],+ Shape::Cylinder(_, r, h) => PI * r * r * h,+ }+ }++ fn counts(self) -> [usize; 3] {+ match self {+ Shape::Box(..) => [6, 12, 8],+ Shape::Cylinder(..) => [3, 3, 2],+ }+ }++ /// The corners of its bounding box.+ fn corners(self) -> Vec<[f64; 3]> {+ let (lo, hi) = match self {+ Shape::Box(o, s) => (o, [o[0] + s[0], o[1] + s[1], o[2] + s[2]]),+ Shape::Cylinder(o, r, h) => ([o[0] - r, o[1] - r, o[2]], [o[0] + r, o[1] + r, o[2] + h]),+ };+ (0..8)+ .map(|k| [if k & 1 == 0 { lo[0] } else { hi[0] }, if k & 2 == 0 { lo[1] } else { hi[1] }, if k & 4 == 0 { lo[2] } else { hi[2] }])+ .collect()+ }+}++/// `p·A + t`.+fn apply(m: &[[f64; 4]; 4], p: [f64; 3]) -> [f64; 3] {+ [0, 1, 2].map(|j| p[0] * m[0][j] + p[1] * m[1][j] + p[2] * m[2][j] + m[3][j])+}++fn det(m: &[[f64; 4]; 4]) -> f64 {+ m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])+ + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0])+}++fn rotation_z(a: f64) -> [[f64; 4]; 4] {+ let (s, c) = a.sin_cos();+ [[c, s, 0.0, 0.0], [-s, c, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]+}++struct Case {+ shape: Shape,+ matrix: [[f64; 4]; 4],+ /// `None`: the closed form (volume times |det|, the moved box, the same counts).+ fails: Option<Error>,+}++const BOX: Shape = Shape::Box([1.0, 2.0, 3.0], [10.0, 20.0, 30.0]);+const CYL: Shape = Shape::Cylinder([0.0, 0.0, 0.0], 5.0, 12.0);++fn case(name: &str) -> Case {+ let ok = |shape, matrix| Case { shape, matrix, fails: None };+ let mut moved = ID;+ moved[3] = [5.0, -7.0, 11.0, 1.0];+ match name {+ "identity" => ok(BOX, ID),+ "translation" => ok(BOX, moved),+ "rotation_about_z" => ok(BOX, rotation_z(PI / 2.0)),+ "uniform_scale" => ok(BOX, [[2.0, 0.0, 0.0, 0.0], [0.0, 2.0, 0.0, 0.0], [0.0, 0.0, 2.0, 0.0], [1.0, 1.0, 1.0, 1.0]]),+ "mirror_in_x" => ok(BOX, [[-1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0; 4]]),+ "non_uniform_scale" => ok(BOX, [[2.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.5, 0.0], [0.0; 4]]),+ "shear" => ok(BOX, [[1.0, 0.5, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [2.0, 3.0, 4.0, 1.0]]),+ "cylinder_moved" => ok(CYL, moved),+ "cylinder_rotated" => ok(CYL, rotation_z(0.3)),+ "cylinder_mirrored" => ok(CYL, [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, -1.0, 0.0], [0.0; 4]]),+ "cylinder_scaled" => ok(CYL, [[3.0, 0.0, 0.0, 0.0], [0.0, 3.0, 0.0, 0.0], [0.0, 0.0, 3.0, 0.0], [0.0; 4]]),+ _ => panic!("no case {name}"),+ }+}++#[derive(Debug, PartialEq)]+struct Measured {+ volume: f64,+ bounds: ([f64; 3], [f64; 3]),+ counts: [usize; 3],+ kinds: BTreeMap<String, usize>,+}++type Got = std::result::Result<Measured, Error>;++fn kinds(rec: &solidcraft_geom::brep::Brep) -> BTreeMap<String, usize> {+ let mut out = BTreeMap::new();+ for f in &rec.faces {+ let v = serde_json::to_value(&f.surface).unwrap();+ *out.entry(v["kind"].as_str().unwrap_or("?").to_owned()).or_default() += 1;+ }+ out+}++fn rel(a: f64, b: f64) -> f64 {+ (a - b).abs() / b.abs()+}++/// The moved shape's bounding box: a box's moved corners bound it exactly; a cylinder's only for+/// the matrices here (a rotation about its axis, a move, a mirror in z, a uniform scale), whose+/// moved circle's box is the moved square's turned back to the axes.+fn expected_bounds(c: &Case) -> ([f64; 3], [f64; 3]) {+ let pts: Vec<[f64; 3]> = match c.shape {+ Shape::Cylinder(o, r, h) => {+ let s = (c.matrix[0][0] * c.matrix[0][0] + c.matrix[0][1] * c.matrix[0][1]).sqrt();+ let centre = [apply(&c.matrix, o), apply(&c.matrix, [o[0], o[1], o[2] + h])];+ centre.iter().flat_map(|p| [[p[0] - r * s, p[1] - r * s, p[2]], [p[0] + r * s, p[1] + r * s, p[2]]]).collect()+ }+ s => s.corners().into_iter().map(|p| apply(&c.matrix, p)).collect(),+ };+ let mut lo = [f64::INFINITY; 3];+ let mut hi = [f64::NEG_INFINITY; 3];+ for p in pts {+ for k in 0..3 {+ lo[k] = lo[k].min(p[k]);+ hi[k] = hi[k].max(p[k]);+ }+ }+ (lo, hi)+}++fn judge(name: &str, who: &str, got: Got) -> Got {+ let c = case(name);+ match (&c.fails, &got) {+ (Some(e), Err(g)) => assert_eq!(g, e, "{name}: {who} failed otherwise"),+ (Some(e), Ok(m)) => panic!("{name}: {who} gave {m:?}, expected {e:?}"),+ (None, Err(g)) => panic!("{name}: {who} failed: {g}"),+ (None, Ok(m)) => {+ let v = c.shape.volume() * det(&c.matrix).abs();+ assert!(rel(m.volume, v) < 1e-9, "{name}: {who} volume {} vs analytic {v}", m.volume);+ assert_eq!(m.counts, c.shape.counts(), "{name}: {who} counts");+ let (lo, hi) = expected_bounds(&c);+ let near = |a: [f64; 3], b: [f64; 3]| a.iter().zip(&b).all(|(x, y)| (x - y).abs() < 1e-6);+ assert!(near(m.bounds.0, lo) && near(m.bounds.1, hi), "{name}: {who} bounds {:?}, expected {lo:?} {hi:?}", m.bounds);+ }+ }+ got+}++fn solidcore_case(name: &str) -> Got {+ let c = case(name);+ let got = transform(&c.shape.core(), &c.matrix).map(|b| {+ let (rec, _) = native(&to_arrays(&b).unwrap()).unwrap_or_else(|e| panic!("{name}: record: {e:?}"));+ rec.validate().unwrap_or_else(|e| panic!("{name}: record: {e}"));+ Measured { volume: volume(&b, 1e-8).unwrap(), bounds: bounds(&b).unwrap(), counts: counts(&b).unwrap(), kinds: kinds(&rec) }+ });+ judge(name, "solidcore", got)+}++/// The case on the C++ kernel, called directly (whatever the choice).+#[cfg(feature = "native")]+fn cpp_case(name: &str) -> Got {+ use crate::{Brep, error, ffi};+ crate::init().unwrap();+ let c = case(name);+ let body = match c.shape {+ Shape::Box(o, s) => ffi::make_box(&o, &s).unwrap(),+ Shape::Cylinder(o, r, h) => ffi::make_cylinder(&o, r, h).unwrap(),+ };+ let got = ffi::transform(&body, &c.matrix).map_err(error).map(|h| {+ let volume = ffi::volume(&h, 1e-8).unwrap();+ let n = ffi::counts(&h).unwrap().map(|x| usize::try_from(x).unwrap());+ let bx = ffi::measure::bounds(&h).unwrap();+ let (rec, _) = native(&Brep::made(h).cpp_arrays().unwrap()).unwrap();+ rec.validate().unwrap();+ Measured { volume, bounds: bx, counts: n, kinds: kinds(&rec) }+ });+ judge(name, "C++", got)+}++/// solidcore and C++ agree: volume within 1e-9, the same counts, bounds and faces by kind, or the+/// same error.+#[cfg(feature = "native")]+fn parity(name: &str) {+ let (ours, cpp) = (solidcore_case(name), cpp_case(name));+ match (ours, cpp) {+ (Ok(a), Ok(b)) => {+ assert!(rel(a.volume, b.volume) < 1e-9, "{name}: solidcore {} vs C++ {}", a.volume, b.volume);+ assert_eq!(a.counts, b.counts, "{name}: counts (solidcore vs C++)");+ assert_eq!(a.kinds, b.kinds, "{name}: faces by surface kind (solidcore vs C++)");+ let near = |x: [f64; 3], y: [f64; 3]| x.iter().zip(&y).all(|(p, q)| (p - q).abs() < 1e-6);+ assert!(near(a.bounds.0, b.bounds.0) && near(a.bounds.1, b.bounds.1), "{name}: bounds {:?} vs C++ {:?}", a.bounds, b.bounds);+ }+ (a, b) => assert_eq!(a.err(), b.err(), "{name}: errors (solidcore vs C++)"),+ }+}++macro_rules! cases {+ ($($m:ident $(: $ign:meta)?),* $(,)?) => {$(+ mod $m {+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_closed_form() {+ let _ = super::solidcore_case(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ super::parity(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ fn the_cpp_kernel_matches_the_closed_form() {+ let _cpp = crate::route::on_cpp();+ let _ = super::cpp_case(stringify!($m));+ }+ }+ )*};+}++cases!(+ identity,+ translation,+ rotation_about_z,+ uniform_scale,+ mirror_in_x,+ non_uniform_scale,+ shear,+ cylinder_moved,+ cylinder_rotated,+ cylinder_mirrored,+ cylinder_scaled,+);++/// The capi's argument check, before any kernel call: every entry finite.+#[test]+fn hostile_matrices_are_refused() {+ let b = BOX.core();+ for (i, j) in [(0, 0), (1, 2), (3, 1), (2, 3)] {+ for x in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {+ let mut m = ID;+ m[i][j] = x;+ assert_eq!(transform(&b, &m).err(), Some(Error::Argument), "m[{i}][{j}] = {x}");+ }+ }+}++/// A singular or huge matrix never panics: it gives a body or an error.+#[test]+fn degenerate_matrices_do_not_crash() {+ let b = BOX.core();+ let zero = [[0.0; 4]; 4];+ let flat = [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0; 4]];+ let huge = [[1e300, 0.0, 0.0, 0.0], [0.0, 1e300, 0.0, 0.0], [0.0, 0.0, 1e300, 0.0], [0.0; 4]];+ for m in [zero, flat, huge] {+ let _ = transform(&b, &m);+ }+}++/// The body moved, and the body copied, are never changed.+#[test]+fn the_body_stays_as_it_was() {+ let b = BOX.core();+ let moved = transform(&b, &rotation_z(1.0)).unwrap();+ let c = copy(&b).unwrap();+ drop(moved);+ for x in [&b, &c] {+ assert_eq!(counts(x).unwrap(), [6, 12, 8]);+ assert!(rel(volume(x, 1e-8).unwrap(), 6000.0) < 1e-12);+ assert_eq!(bounds(x).unwrap(), ([1.0, 2.0, 3.0], [11.0, 22.0, 33.0]));+ }+}++/// Face and edge tags (`Brep::tagged`) through a copy and a transform on solidcore, as on+/// C++: the box is tagged on the C++ kernel, its solidcore body converted from that and tagged the+/// same way, and the two results' histories must be the same.+#[cfg(feature = "native")]+mod history {+ use crate::{Brep, ffi};++ fn tagged_box() -> Brep {+ crate::init().unwrap();+ Brep::made(ffi::make_box(&[0.0; 3], &[20.0, 30.0, 10.0]).unwrap()).tagged(0).unwrap()+ }++ #[test]+ fn tags_cross_a_copy() {+ let _cpp = crate::route::on_cpp();+ let a = tagged_box();+ let cpp = Brep::made(ffi::copy(a.cpp().unwrap()).unwrap()).history().unwrap();+ let core = Brep::made_core(super::copy(a.core().unwrap()).unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical());+ }++ #[test]+ fn tags_cross_a_mirror_and_a_shear() {+ let _cpp = crate::route::on_cpp();+ let a = tagged_box();+ let mirror = [[-1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0; 4]];+ let shear = [[1.0, 0.5, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [2.0, 3.0, 4.0, 1.0]];+ for m in [mirror, shear] {+ let cpp = Brep::made(ffi::transform(a.cpp().unwrap(), &m).unwrap()).history().unwrap();+ let core = Brep::made_core(super::transform(a.core().unwrap(), &m).unwrap()).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical(), "{m:?}");+ }+ }+}diff --git a/crates/smlib/src/core/trim.rs b/crates/smlib/src/core/trim.rsnew file mode 100644index 0000000000..53ba9ab69a--- /dev/null+++ b/crates/smlib/src/core/trim.rs@@ -0,0 +1,862 @@+//! Untrim and extend on solidcore: the C API's `smlib_untrim_face` and `smlib_extend_sheet`,+//! ported from the fork's `capi/src/smlib_untrim.cpp` (`face_at`, `loop_distance`,+//! `copy_attributes`, `analytic`, `span_of`, `pieces_of`, `is_disc`, `rebuild_hole`) and+//! `capi/src/smlib_extend.cpp` (`on_side`, `eval`, `nearest_edge`, `is_boundary`, `side_edge`,+//! `across`, `cone_continued`, `same_patch`).+//!+//! A face restored towards its surface. Picked inner loops (holes) are taken away with+//! `SmFace::DeleteInnerLoop` on a copy where they are lamina; the outer boundary goes back to a+//! parameter box of the surface (`SmBrep::CreateFaceFromSurface`), and the holes kept are rebuilt+//! in that face from their own edges' curves and intervals (`MakeVertexLoop`, `MakeEdgeInFace`:+//! closing a loop splits off the face inside it, which is deleted). The new face and the rebuilt+//! edges take the attributes of the face and edges they stand for, so the history tags carry+//! through.+//!+//! A sheet is extended by SMLib's extension of its surface (`CreateExtendedSurface`: its end+//! spans continued, or a G1 or G2 run-off), the distance asked of it corrected until the+//! extension measures the distance across the side's middle; `CopyAndAddAnalytics` gives the+//! result back its analytic kind, and a cone or cylinder continued naturally stays the analytic+//! widened. The new face and each of its sides take the attributes of the face and side they+//! continue.+//!+//! An untrim of a face out of its body (`in_place` false) copies the face into a body of its own+//! through `SmBrep::CopyFaces` with the merge (solidcore#1872), which keeps its attributes.++use std::sync::PoisonError;++use solidcore::EntityRef;+use solidcore::curve::curve::Curve;+use solidcore::geom::extent2d::Extent2d;+use solidcore::geom::geom_utility::p2::ContinuityType;+use solidcore::geom::object::Shape;+use solidcore::geom::tol::USE_DEFAULT;+use solidcore::geom::vector2d::Point2;+use solidcore::geom::vector3d::{Point3, Vec3};+use solidcore::kernel::Kernel;+use solidcore::nurbs::b_spline_surface::p1::SurfParamType;+use solidcore::nurbs::b_spline_surface_n_lib::p2::EvaluateFlags;+use solidcore::nurbs::b_spline_surface_n_lib::p2::OrientType;+use solidcore::query::api_queries::{edge_closest_point, face_closest_point_in_shape, face_internal_point};+use solidcore::query::brep::{BrepQuery, LiveBrepObjects};+use solidcore::surface::cone::p1::Cone;+use solidcore::surface::surface::Surface;+use solidcore::surface::surface::SurfaceKind;+use solidcore::topology::brep::p1 as brep_p1;+use solidcore::topology::brep::p2::{CopyNotifyState, copy_source_ref};+use solidcore::topology::brep::p3::{DeleteFaceOptions, delete_face, new_brep, with_kernel_callbacks};+use solidcore::topology::brep::p5::{EdgeInFace, make_edge_in_face};+use solidcore::topology::brep::p7::copy_faces_from;+use solidcore::topology::brep::p8::create_face_from_surface;+use solidcore::topology::brep::p9::make_vertex_loop;+use solidcore::topology::edgeuse::p1 as eu_p1;+use solidcore::topology::edgeuse::p3::get_or_create_uv_trim_curve;+use solidcore::topology::face::{p1 as face_p1, p2 as face_p2, p4 as face_p4};+use solidcore::topology::loopuse::{loop_edges, loop_loopuses, notify_ref};+use solidcore::topology::topology_traverser::Marks;+use solidcore::topology::{Brep, BrepId, EdgeId, FaceId, LoopId, edge};++use super::blend::{p3, status};+use super::sweep::build_faces;+use super::{Body, answer, run};+use crate::trim::Continuation;+use crate::{Error, Result};+use solidcore::topology::brep::p3::brep_copy;++/// `MAX_HOLE_POINTS`.+const MAX_HOLE_POINTS: usize = 10_000;++/// `SMLIB_ERR_EXCEPTION`'s stand-in: a rebuilt hole that did not close as the capi expects.+fn hole_refused() -> Error {+ Error::Exception+}++/// The capi's statuses as SolidCraft errors: an operation's own result.+type Out<T> = std::result::Result<T, Error>;++const ONE: BrepId = BrepId::from_index(0);++/// `face_at`: the face of `b` nearest `p`, within `tol` (`SmApiFaceClosestPoint`; a face whose+/// query fails is skipped).+fn face_at(k: &mut Kernel, b: &mut Brep, p: Point3, tol: f64) -> solidcore::Result<Option<FaceId>> {+ let all = brep_p1::faces(b, None)?;+ let mut shapes = Vec::with_capacity(all.len());+ for &f in &all {+ shapes.push(answer(Shape::new(k, &(ONE, &*b), &[], &[(ONE, f)], &[], &[]))?);+ }+ let query = BrepQuery::of_brep(b);+ let identity = query.effective_identity();+ let objects = LiveBrepObjects::new(b, &identity, None)?;+ let (mut best, mut d0) = (None, f64::INFINITY);+ for (&f, shape) in all.iter().zip(&shapes) {+ let Some(shape) = shape else { continue };+ if let Some(c) = answer(face_closest_point_in_shape(k, shape, &objects, (ONE, f), p))?+ && c.distance.is_finite()+ && c.distance < d0+ {+ d0 = c.distance;+ best = Some(f);+ }+ }+ Ok(best.filter(|_| d0 <= tol))+}++/// `loop_distance`: the distance from `p` to the nearest edge of loop `l`.+fn loop_distance(k: &Kernel, b: &Brep, l: LoopId, p: Point3) -> solidcore::Result<f64> {+ let mut best = f64::INFINITY;+ for e in loop_edges(b, l)?.into_iter().flatten() {+ if let Some(c) = answer(edge_closest_point(k, b, e, p))?+ && c.closest.distance.is_finite()+ {+ best = best.min(c.closest.distance);+ }+ }+ Ok(best)+}++/// `copy_attributes`: `to` (in `into`) takes a copy of each attribute of `from` (in `src`).+fn copy_attributes(src: &Brep, from: EntityRef, into: &mut Brep, to: EntityRef) -> solidcore::Result<()> {+ let copies: Vec<_> = src.entity_attributes(from).into_iter().map(|(_, a)| a.make_copy()).collect();+ for a in copies {+ into.add_attribute(to, a)?;+ }+ Ok(())+}++/// [`copy_attributes`] within one body.+fn copy_attributes_within(b: &mut Brep, from: EntityRef, to: EntityRef) -> solidcore::Result<()> {+ let copies: Vec<_> = b.entity_attributes(from).into_iter().map(|(_, a)| a.make_copy()).collect();+ for a in copies {+ b.add_attribute(to, a)?;+ }+ Ok(())+}++/// `span_of`: the box of the face's outer loop in the surface's parameters, the union of the+/// tight boxes of its edgeuses' UV trim curves (made where the face has none attached yet).+fn span_of(k: &Kernel, b: &mut Brep, outer: LoopId) -> solidcore::Result<Option<Extent2d>> {+ let (lu, _) = loop_loopuses(b, outer)?;+ let eus = eu_p1::loopuse_edgeuses(b, lu)?;+ let (mut lo, mut hi) = ([f64::INFINITY; 2], [f64::NEG_INFINITY; 2]);+ let mut any = false;+ for eu in eus {+ let fetched = get_or_create_uv_trim_curve(k, b, eu, false, false, true)?;+ if fetched.status.is_err() {+ return Ok(None);+ }+ let (Some(uv), _) = eu_p1::uv_trim_curve(b, eu)? else { return Ok(None) };+ let Some(e) = answer(uv.calculate_tight_bounding_box(k, &uv.natural_interval()))? else { return Ok(None) };+ let (mn, mx) = (e.min(), e.max());+ lo = [lo[0].min(mn.x), lo[1].min(mn.y)];+ hi = [hi[0].max(mx.x), hi[1].max(mx.y)];+ any = true;+ }+ if !any || !(hi[0] > lo[0]) || !(hi[1] > lo[1]) || !(lo[0] + lo[1] + hi[0] + hi[1]).is_finite() {+ return Ok(None);+ }+ Ok(Some(Extent2d::from_bounds(lo[0], lo[1], hi[0], hi[1])))+}++/// One edge of a hole to rebuild: its edge, how the loop runs along it, its ends as the loop+/// runs, its curve and interval (`Piece`).+struct Piece {+ edge: EdgeId,+ orient: OrientType,+ from: Point3,+ to: Point3,+ curve: Curve,+ interval: solidcore::geom::extent1d::Extent1d,+}++/// `pieces_of`; `None` where the capi gives up.+fn pieces_of(b: &Brep, l: LoopId) -> solidcore::Result<Option<Vec<Piece>>> {+ let (lu, _) = loop_loopuses(b, l)?;+ let mut out = Vec::new();+ for eu in eu_p1::loopuse_edgeuses(b, lu)? {+ let Some(e) = eu_p1::edge(b, eu)? else { return Ok(None) };+ let ed = b.edge(e)?;+ let Some(curve) = ed.curve.clone() else { return Ok(None) };+ let (Some(v0), Some(v1)) = edge::start_end_vertices(b, e)? else { return Ok(None) };+ let same = eu_p1::orientation(b, eu)? == OrientType::Same;+ let (p0, p1) = (b.vertex(v0)?.point, b.vertex(v1)?.point);+ let (from, to) = if same { (p0, p1) } else { (p1, p0) };+ out.push(Piece { edge: e, orient: if same { OrientType::Same } else { OrientType::Opposite }, from, to, curve, interval: ed.interval });+ }+ Ok((!out.is_empty()).then_some(out))+}++/// `is_disc`: whether `f` is bounded by one loop of exactly the edges `made`.+fn is_disc(b: &Brep, f: FaceId, made: &[EdgeId]) -> solidcore::Result<bool> {+ let loops = face_p2::loops(b, f, false, None)?;+ let [l] = loops.as_slice() else { return Ok(false) };+ let edges: Vec<EdgeId> = loop_edges(b, *l)?.into_iter().flatten().collect();+ Ok(edges.len() == made.len() && edges.iter().all(|e| made.contains(e)))+}++/// `rebuild_hole`: the hole `pieces` (edges of `src`) rebuilt in `face` of `r`: vertices and+/// edges made in the face, the face the closed loop splits off inside it deleted. `face` is the+/// face that keeps the rest.+fn rebuild_hole(k: &mut Kernel, src: Option<&Brep>, r: &mut Brep, face: &mut FaceId, pieces: &[Piece]) -> solidcore::Result<Out<()>> {+ let Some(first_piece) = pieces.first() else { return Ok(Err(hole_refused())) };+ let editing = r.editing_enabled();+ r.set_editing_enabled(true);+ let tol = r.tolerance();+ // Each edit notifies through the kernel's callbacks with the body's own attributes+ // (`MakeEdgeInFace` does so itself), so the history tags follow.+ let vertex_loop = |k: &mut Kernel, r: &mut Brep, face: FaceId, at: Point3| {+ with_kernel_callbacks(k, r, |_, r, env| make_vertex_loop(r, face, at, OrientType::Opposite, env))+ };+ let done = (|| -> solidcore::Result<Out<()>> {+ let (_, first) = match vertex_loop(k, r, *face, first_piece.from) {+ Ok(v) => v,+ Err(e) => return Ok(Err(status(e))),+ };+ let mut at = first;+ let mut made = Vec::with_capacity(pieces.len());+ let mut split = None;+ for (i, p) in pieces.iter().enumerate() {+ let last = i + 1 == pieces.len();+ let next = if last {+ first+ } else {+ match vertex_loop(k, r, *face, p.to) {+ Ok((_, v)) => v,+ Err(e) => return Ok(Err(status(e))),+ }+ };+ let curve = p.curve.copy(k)?;+ let mut out = EdgeInFace::default();+ if let Err(e) = make_edge_in_face(k, r, true, Some(*face), Some(at), Some(next), curve, None, p.interval, p.orient, tol, &mut out, None) {+ return Ok(Err(status(e)));+ }+ let Some(e) = out.edge else { return Ok(Err(Error::Empty)) };+ match src {+ Some(s) => copy_attributes(s, EntityRef::Edge(p.edge), r, EntityRef::Edge(e))?,+ None => copy_attributes_within(r, EntityRef::Edge(p.edge), EntityRef::Edge(e))?,+ }+ made.push(e);+ if let Some(nf) = out.face {+ if !last || split.is_some() {+ return Ok(Err(hole_refused()));+ }+ split = Some(nf);+ }+ at = next;+ }+ let Some(split) = split else { return Ok(Err(hole_refused())) };+ // One of the two faces is the disc inside the hole: it goes, its edges stay on the other.+ let disc = if is_disc(r, split, &made)? {+ split+ } else if is_disc(r, *face, &made)? {+ *face+ } else {+ return Ok(Err(hole_refused()));+ };+ let rest = if disc == split { *face } else { split };+ let deleted = with_kernel_callbacks(k, r, |k, r, env| {+ let mut marks = Marks::default();+ let options = DeleteFaceOptions { delete_edges_vertices: false, ..DeleteFaceOptions::default() };+ delete_face(k, r, env, &mut marks, disc, options)+ });+ if let Err(e) = deleted {+ return Ok(Err(status(e)));+ }+ *face = rest;+ Ok(Ok(()))+ })();+ r.set_editing_enabled(editing);+ r.refresh_cached_topology();+ done+}++/// The orientation of `f`'s upward faceuse.+fn upward(b: &Brep, f: FaceId) -> solidcore::Result<Option<OrientType>> {+ Ok(match face_p2::upward_faceuse(b, f)? {+ Some(fu) => Some(b.faceuse(fu)?.orientation),+ None => None,+ })+}++/// `smlib_untrim_face`: the face of `body` nearest `point` (within `tol`) restored towards its+/// surface: the holes nearest `holes` (all of them for `None`) taken away and, with `outer`, its+/// outer boundary back on the surface's parameter box. The face alone, or with `in_place` the+/// whole body with it replaced.+pub(crate) fn untrim_face(body: &Body, point: [f64; 3], tol: f64, holes: Option<&[[f64; 3]]>, outer: bool, in_place: bool) -> Result<Body> {+ let n_holes = holes.map(<[_]>::len);+ if !point.iter().all(|x| x.is_finite())+ || !tol.is_finite()+ || !(tol > 0.0)+ || n_holes.is_some_and(|n| n > MAX_HOLE_POINTS)+ || holes.is_some_and(|h| !h.iter().flatten().all(|x| x.is_finite()))+ || (n_holes == Some(0) && !outer)+ {+ return Err(Error::Argument);+ }+ if body.0.is_poisoned() {+ return Err(Error::Internal("smlib_untrim_face: the body was left unfinished by an earlier panic".to_owned()));+ }+ let at = p3(point);+ run("smlib_untrim_face", |k| {+ let mut whole = {+ let g = body.0.lock().unwrap_or_else(PoisonError::into_inner);+ super::dump::input(k, "brep", &g);+ brep_copy(k, &g)?+ };+ // The face to untrim, in a body of its own (its hole edges lamina there) or in the copy+ // of the whole body.+ let (mut w, f) = if in_place {+ let f = face_at(k, &mut whole, at, tol)?;+ (whole, f)+ } else {+ let Some(src) = face_at(k, &mut whole, at, tol)? else { return Ok(Err(Error::NoMatch { point: 0 })) };+ let mut w = new_brep(k, USE_DEFAULT, USE_DEFAULT)?;+ w.set_tolerance(whole.tolerance());+ // Through SmMerge, with both bodies' attributes in the notifications, so the copy+ // carries its source's history tags (`SM_NO_COPY`).+ let copied = {+ let mut state = CopyNotifyState::with_attributes_of(&mut whole, &mut w)?;+ let this_face = |f: FaceId| notify_ref(EntityRef::Face(f));+ let copied = copy_faces_from(k, &mut whole, &[src], &mut w, true, ©_source_ref, &this_face, &mut state.env(None));+ state.restore_attributes(&mut whole, &mut w)?;+ copied+ };+ let copied = match copied {+ Ok((c, _)) => c,+ Err(e) => return Ok(Err(status(e))),+ };+ // The capi's `copied.GetSize() != 1`: `SMLIB_ERR_EMPTY`.+ let [f] = copied.as_slice() else { return Ok(Err(Error::Empty)) };+ w.refresh_cached_topology();+ (w, Some(*f))+ };+ let Some(f) = f else { return Ok(Err(Error::NoMatch { point: 0 })) };+ let loops = face_p2::loops(&w, f, false, None)?;+ if loops.is_empty() {+ return Ok(Err(Error::Unsupported));+ }+ let inner = loops.get(1..).unwrap_or_default();+ // The holes taken away: all of them, or the one nearest each point.+ let mut removed: Vec<LoopId> = Vec::new();+ match holes {+ None => removed.extend_from_slice(inner),+ Some(points) => {+ for p in points {+ let p = p3(*p);+ let (mut best, mut d0) = (None, f64::INFINITY);+ for &l in inner {+ let d = loop_distance(k, &w, l, p)?;+ if d < d0 {+ d0 = d;+ best = Some(l);+ }+ }+ let Some(best) = best.filter(|_| d0 <= tol) else { return Ok(Err(Error::NoMatch { point: 0 })) };+ if !removed.contains(&best) {+ removed.push(best);+ }+ }+ }+ }+ if !outer {+ for &l in &removed {+ // A hole whose edges another face of the body uses is no hole of a sheet.+ let deleted = face_p1::delete_inner_loop_with_kernel_callbacks(k, &mut w, f, l);+ if deleted.is_err() {+ return Ok(Err(Error::Unsupported));+ }+ }+ w.refresh_cached_topology();+ return Ok(Ok(w));+ }+ // The outer boundary: the surface's parameter box (a free-form surface's own, an+ // analytic one's the span of the face).+ let Some(surf) = face_p2::surface(&w, f)?.cloned() else { return Ok(Err(Error::Unsupported)) };+ let mut bx = surf.natural_uv_domain_with_nurb(k)?;+ if !matches!(surf.kind(), SurfaceKind::BSpline(_)) {+ let Some(outer_loop) = loops.first() else { return Ok(Err(Error::Unsupported)) };+ match span_of(k, &mut w, *outer_loop)? {+ Some(s) => bx = s,+ None => return Ok(Err(Error::Unsupported)),+ }+ }+ let mut kept = Vec::new();+ for &l in inner {+ if removed.contains(&l) {+ continue;+ }+ match pieces_of(&w, l)? {+ Some(p) => kept.push(p),+ None => return Ok(Err(Error::Unsupported)),+ }+ }+ let copy = surf.copy(k)?;+ let was = upward(&w, f)?;+ let mut r = if in_place {+ None+ } else {+ let mut r = new_brep(k, USE_DEFAULT, USE_DEFAULT)?;+ r.set_tolerance(w.tolerance());+ Some(r)+ };+ let target: &mut Brep = match r.as_mut() {+ Some(r) => r,+ None => &mut w,+ };+ let mut nf = match build_faces(target, |t, fenv| create_face_from_surface(k, t, Some(copy), &bx, fenv)) {+ Ok(nf) => nf,+ Err(e) => return Ok(Err(status(e))),+ };+ target.refresh_cached_topology();+ let _ = target;+ for hole in &kept {+ let done = match r.as_mut() {+ Some(r) => rebuild_hole(k, Some(&w), r, &mut nf, hole)?,+ None => rebuild_hole(k, None, &mut w, &mut nf, hole)?,+ };+ if let Err(e) = done {+ return Ok(Err(e));+ }+ }+ match r.as_mut() {+ Some(r) => copy_attributes(&w, EntityRef::Face(f), r, EntityRef::Face(nf))?,+ None => copy_attributes_within(&mut w, EntityRef::Face(f), EntityRef::Face(nf))?,+ }+ // The face faces the way the old one did.+ let target: &mut Brep = match r.as_mut() {+ Some(r) => r,+ None => &mut w,+ };+ let now = upward(target, nf)?;+ if let (Some(a), Some(b)) = (was, now)+ && a != b+ && let Err(e) = face_p1::flip_face_orientation(target, nf)+ {+ return Ok(Err(status(e)));+ }+ if let Some(r) = r {+ return Ok(Ok(r));+ }+ // The old face goes, with the edges and vertices only it used: an edit of the brep,+ // which SMLib allows only in edit mode.+ let editing = w.editing_enabled();+ w.set_editing_enabled(true);+ let deleted = with_kernel_callbacks(k, &mut w, |k, w, env| {+ let mut marks = Marks::default();+ let options = DeleteFaceOptions { delete_edges_vertices: true, ..DeleteFaceOptions::default() };+ delete_face(k, w, env, &mut marks, f, options)+ });+ w.set_editing_enabled(editing);+ w.refresh_cached_topology();+ if let Err(e) = deleted {+ return Ok(Err(status(e)));+ }+ Ok(Ok(w))+ })?+ .map(Body::new)+}++/// One side of a face's parameter box (`Side`): which, whether it is a u = const line (the face+/// grows in u), and whether it is at the box's max.+#[derive(Clone, Copy)]+struct Side {+ which: SurfParamType,+ u: bool,+ high: bool,+}++/// `SIDES`.+const SIDES: [Side; 4] = [+ Side { which: SurfParamType::UMin, u: true, high: false },+ Side { which: SurfParamType::UMax, u: true, high: true },+ Side { which: SurfParamType::VMin, u: false, high: false },+ Side { which: SurfParamType::VMax, u: false, high: true },+];++/// `SAMPLES`.+const SAMPLES: usize = 9;++/// `on_side`: the point of side `s` of `dom` at `t` in [0, 1] along it, in UV.+fn on_side(dom: &Extent2d, s: Side, t: f64) -> Point2 {+ let (lo, hi) = (dom.min(), dom.max());+ if s.u {+ Point2::new(if s.high { hi.x } else { lo.x }, lo.y + t * (hi.y - lo.y))+ } else {+ Point2::new(lo.x + t * (hi.x - lo.x), if s.high { hi.y } else { lo.y })+ }+}++/// `eval`: the point at `uv` with its u and v derivatives; `None` where it does not evaluate or+/// is not finite.+fn eval(k: &Kernel, surf: &Surface, uv: Point2) -> Option<(Vec3, Vec3, Vec3)> {+ let d = surf.evaluate(k, uv, 1, 1, EvaluateFlags::default()).ok()?;+ let p = *d.first()?.first()?;+ let du = *d.get(1)?.first()?;+ let dv = *d.first()?.get(1)?;+ (p.length().is_finite() && du.length().is_finite() && dv.length().is_finite()).then_some((p, du, dv))+}++fn point_at(k: &Kernel, surf: &Surface, uv: Point2) -> Option<Vec3> {+ eval(k, surf, uv).map(|(p, _, _)| p)+}++/// `edge_distance`.+fn edge_distance(k: &Kernel, b: &Brep, e: EdgeId, p: Vec3) -> f64 {+ match edge_closest_point(k, b, e, p) {+ Ok(c) if c.closest.distance.is_finite() => c.closest.distance,+ _ => f64::INFINITY,+ }+}++/// `nearest_edge`: the distance to the nearest of `edges`, with that edge.+fn nearest_edge(k: &Kernel, b: &Brep, edges: &[EdgeId], p: Vec3) -> (f64, Option<EdgeId>) {+ let (mut best, mut which) = (f64::INFINITY, None);+ for &e in edges {+ let d = edge_distance(k, b, e, p);+ if d < best {+ best = d;+ which = Some(e);+ }+ }+ (best, which)+}++/// `is_boundary`: whether side `s` of the face's box is a side of the face (its samples on the+/// face's edges), and whether it collapses to a point (a pole).+fn is_boundary(k: &Kernel, b: &Brep, surf: &Surface, dom: &Extent2d, s: Side, edges: &[EdgeId], tol: f64) -> (bool, bool) {+ let (Some(a), Some(z), Some(m)) =+ (point_at(k, surf, on_side(dom, s, 0.0)), point_at(k, surf, on_side(dom, s, 1.0)), point_at(k, surf, on_side(dom, s, 0.5)))+ else {+ return (false, false);+ };+ if (a - z).length() <= tol && (a - m).length() <= tol {+ return (true, true);+ }+ let all = (0..=SAMPLES).all(|i| match point_at(k, surf, on_side(dom, s, i as f64 / SAMPLES as f64)) {+ Some(p) => nearest_edge(k, b, edges, p).0 <= tol,+ None => false,+ });+ (all, false)+}++/// `side_edge`: the edge of `edges` side `s` of `dom` runs along (nearest the side's middle), or+/// `None` for a side collapsed to a point.+fn side_edge(k: &Kernel, b: &Brep, surf: &Surface, dom: &Extent2d, s: Side, edges: &[EdgeId], on: f64) -> Option<EdgeId> {+ let a = point_at(k, surf, on_side(dom, s, 0.0))?;+ let z = point_at(k, surf, on_side(dom, s, 1.0))?;+ let m = point_at(k, surf, on_side(dom, s, 0.5))?;+ if (a - z).length() <= on && (a - m).length() <= on {+ return None;+ }+ let (d, e) = nearest_edge(k, b, edges, m);+ e.filter(|_| d <= on)+}++/// `across`: how far `ext` (the face's surface extended past side `s` of its box `dom`, on the+/// same parameters) runs past that side, measured across it through the side's middle, by+/// 16-point Gauss-Legendre quadrature on 64 pieces. Negative when it can't be evaluated.+fn across(k: &Kernel, ext: &Surface, dom: &Extent2d, s: Side) -> f64 {+ const X: [f64; 8] = [+ 0.0950125098376374,+ 0.2816035507792589,+ 0.4580167776572274,+ 0.6178762444026438,+ 0.755404408355003,+ 0.8656312023878318,+ 0.9445750230732326,+ 0.9894009349916499,+ ];+ const W: [f64; 8] = [+ 0.1894506104550685,+ 0.1826034150449236,+ 0.1691565193950025,+ 0.1495959888165767,+ 0.1246289712555339,+ 0.0951585116824928,+ 0.0622535239386479,+ 0.0271524594117541,+ ];+ const PIECES: usize = 64;+ let Ok(bx) = ext.natural_uv_domain_with_nurb(k) else { return -1.0 };+ let mid = on_side(dom, s, 0.5);+ let from = if s.u { mid.x } else { mid.y };+ let to = match (s.u, s.high) {+ (true, true) => bx.max().x,+ (true, false) => bx.min().x,+ (false, true) => bx.max().y,+ (false, false) => bx.min().y,+ };+ let h = (to - from) / PIECES as f64;+ let mut length = 0.0;+ for piece in 0..PIECES {+ let c = from + (piece as f64 + 0.5) * h;+ for i in 0..16 {+ let (x, w) = if i < 8 { (-X[i], W[i]) } else { (X[i - 8], W[i - 8]) };+ let t = c + 0.5 * h * x;+ let uv = if s.u { Point2::new(t, mid.y) } else { Point2::new(mid.x, t) };+ let Some((_, du, dv)) = eval(k, ext, uv) else { return -1.0 };+ length += 0.5 * h.abs() * w * if s.u { du } else { dv }.length();+ }+ }+ length+}++/// `cone_continued`: a cone's or cylinder's face continued naturally `distance` past side `s` of+/// its box `dom`, as the analytic itself over a wider STEP domain (degrees round the axis,+/// height along it). `None` where the cone can't be widened so (more than a turn, or past the+/// apex).+fn cone_continued(k: &Kernel, surf: &Surface, dom: &Extent2d, s: Side, distance: f64) -> Option<Surface> {+ let SurfaceKind::Cone(cone) = surf.kind() else { return None };+ let mut cone: Cone = cone.as_ref().clone();+ let step = |uv: Point2| cone.convert_uv_from_nurbs_to_step(k, uv).ok();+ let (a, z, m) = (step(on_side(dom, s, 0.0))?, step(on_side(dom, s, 1.0))?, step(on_side(dom, s, 0.5))?);+ let (lo, hi) = (step(dom.min())?, step(dom.max())?);+ let semi = cone.canonical().semi_angle_deg;+ let mut bx = [[lo.x.min(hi.x), lo.x.max(hi.x)], [lo.y.min(hi.y), lo.y.max(hi.y)]];+ let eps = 1e-9 * (1.0 + m.x.abs() + m.y.abs());+ // The STEP coordinate constant along the side is the one the face grows in.+ let c = if (a.x - z.x).abs() <= eps {+ 0+ } else if (a.y - z.y).abs() <= eps {+ 1+ } else {+ return None;+ };+ let at = if c == 0 { m.x } else { m.y };+ let row = bx.get_mut(c)?;+ let end = if (at - row[1]).abs() <= (at - row[0]).abs() { 1 } else { 0 };+ let by = if c == 0 {+ let r = cone.radius(m.y);+ if !(r > 0.0) {+ return None;+ }+ (distance / r).to_degrees()+ } else {+ distance * semi.to_radians().cos()+ };+ if end == 1 {+ row[1] += by;+ } else {+ row[0] -= by;+ }+ if bx[0][1] - bx[0][0] > 360.0 + 1e-9 {+ return None;+ }+ let wider = Extent2d::from_bounds(bx[0][0], bx[1][0], bx[0][1], bx[1][1]);+ cone.adjust_step_uv_domain(k, &wider).ok()?;+ Some(Surface::from(cone))+}++/// `same_patch`: whether `p` and `q` span the same patch: their boxes' corners the same points,+/// in any order, within `tol`.+fn same_patch(k: &Kernel, p: &Surface, q: &Surface, tol: f64) -> bool {+ let (Ok(bp), Ok(bq)) = (p.natural_uv_domain_with_nurb(k), q.natural_uv_domain_with_nurb(k)) else { return false };+ let corners = |b: &Extent2d| {+ let (lo, hi) = (b.min(), b.max());+ [lo, Point2::new(hi.x, lo.y), hi, Point2::new(lo.x, hi.y)]+ };+ corners(&bp).into_iter().all(|u| {+ let Some(x) = point_at(k, p, u) else { return false };+ corners(&bq).into_iter().any(|v| point_at(k, q, v).is_some_and(|y| (x - y).length() <= tol))+ })+}++/// `extended_by`: the surface `surf` (whose face is its whole box `dom`) extended past side `s` as+/// `ct` says, so that it runs `distance` past that side measured across it ([`across`]), within+/// 1e-9 of it. `CreateExtendedSurface` takes its distance as an estimate, and how far it then runs+/// is increasing in what it is asked: a bracketed solve on that (each ask scaled by the distance+/// over what it gave until two asks fall either side, then Illinois false position). An extension+/// that moves the face's side off its parameters, or a target not met, is [`Error::NotExact`],+/// never the surface as it came out.+fn extended_by(k: &Kernel, surf: &Surface, dom: &Extent2d, s: Side, ct: ContinuityType, distance: f64, model_tol: f64) -> Result<Surface> {+ const BRACKET_TRIES: usize = 40;+ const SOLVE_TRIES: usize = 100;+ let tol = 1e-9 * distance;+ // How far asking `ask` runs, and the surface it makes.+ let try_ask = |ask: f64| -> Result<(Surface, f64)> {+ let tried = surf.create_extended_surface_dir(k, s.which, ask, ct).map_err(status)?;+ // The face's side stays where it was on the extended surface's parameters.+ let mid = on_side(dom, s, 0.5);+ let stays = matches!((point_at(k, surf, mid), point_at(k, &tried, mid)), (Some(was), Some(now)) if (was - now).length() <= model_tol);+ if !stays {+ return Err(Error::NotExact);+ }+ let got = across(k, &tried, dom, s);+ if got.is_finite() && got > 0.0 { Ok((tried, got)) } else { Err(Error::NotExact) }+ };+ // Asks that run short of and past `distance`, by f = got - distance.+ let (mut short, mut past) = (None, None);+ let mut ask = distance;+ for _ in 0..BRACKET_TRIES {+ let (made, got) = try_ask(ask)?;+ let f = got - distance;+ if f.abs() <= tol {+ return Ok(made);+ }+ if f < 0.0 {+ short = Some((ask, f));+ } else {+ past = Some((ask, f));+ }+ if short.is_some() && past.is_some() {+ break;+ }+ ask *= distance / got;+ }+ let (Some((mut lo, mut flo)), Some((mut hi, mut fhi))) = (short, past) else { return Err(Error::NotExact) };+ // Illinois: false position, halving the value at the end that stays when the same end moves+ // twice running.+ #[derive(PartialEq)]+ enum Moved {+ Neither,+ Lo,+ Hi,+ }+ let mut moved = Moved::Neither;+ for _ in 0..SOLVE_TRIES {+ let x = hi - fhi * (hi - lo) / (fhi - flo);+ if !(x > lo.min(hi) && x < lo.max(hi)) {+ break;+ }+ let (made, got) = try_ask(x)?;+ let f = got - distance;+ if f.abs() <= tol {+ return Ok(made);+ }+ if f < 0.0 {+ (lo, flo) = (x, f);+ if moved == Moved::Lo {+ fhi *= 0.5;+ }+ moved = Moved::Lo;+ } else {+ (hi, fhi) = (x, f);+ if moved == Moved::Hi {+ flo *= 0.5;+ }+ moved = Moved::Hi;+ }+ }+ Err(Error::NotExact)+}++/// `smlib_extend_sheet`: the one-face sheet `sheet`, whose face is its surface's whole parameter+/// box, continued `distance` past the side its edge nearest `point` (within `tol`) runs along,+/// as `how` says. A sheet of another shape is [`Error::Unsupported`]; an extension that cannot be+/// made `distance` long across the side (within 1e-9 of it) is [`Error::NotExact`].+pub(crate) fn extend_sheet(sheet: &Body, point: [f64; 3], tol: f64, distance: f64, how: Continuation) -> Result<Body> {+ if !point.iter().all(|x| x.is_finite()) || !tol.is_finite() || !(tol > 0.0) || !distance.is_finite() || !(distance > 0.0) {+ return Err(Error::Argument);+ }+ if sheet.0.is_poisoned() {+ return Err(Error::Internal("smlib_extend_sheet: the body was left unfinished by an earlier panic".to_owned()));+ }+ run("smlib_extend_sheet", |k| {+ let b = {+ let g = sheet.0.lock().unwrap_or_else(PoisonError::into_inner);+ super::dump::input(k, "sheet", &g);+ brep_copy(k, &g)?+ };+ let faces = brep_p1::faces(&b, None)?;+ let [f] = faces.as_slice() else { return Ok(Err(Error::Unsupported)) };+ let f = *f;+ let Some(surf) = face_p2::surface(&b, f)?.cloned() else { return Ok(Err(Error::Unsupported)) };+ if face_p2::loops(&b, f, false, None)?.len() != 1 {+ return Ok(Err(Error::Unsupported));+ }+ let edges = face_p4::edges(&b, f, None, false, None)?;+ let (d, picked) = nearest_edge(k, &b, &edges, p3(point));+ let Some(picked) = picked.filter(|_| d <= tol) else { return Ok(Err(Error::NoMatch { point: 0 })) };+ let model_tol = b.tolerance().max(1e-9);+ let on = 10.0 * model_tol;+ let dom = face_p2::uv_domain(&b, f)?;+ // Every side of the box is a side of the face (the face is its whole box), and the picked+ // edge is all of one side.+ let mut grow = None;+ for s in SIDES {+ let (boundary, collapsed) = is_boundary(k, &b, &surf, &dom, s, &edges, on);+ if !boundary {+ return Ok(Err(Error::Unsupported));+ }+ if collapsed {+ continue;+ }+ let all = (0..=SAMPLES).all(|i| match point_at(k, &surf, on_side(&dom, s, i as f64 / SAMPLES as f64)) {+ Some(p) => edge_distance(k, &b, picked, p) <= on,+ None => false,+ });+ if all {+ grow = Some(s);+ }+ }+ let Some(grow) = grow else { return Ok(Err(Error::Unsupported)) };+ // SMLib extends the whole surface; the face must be all of it.+ let natural = surf.natural_uv_domain_with_nurb(k)?;+ let (nl, nh, dl, dh) = (natural.min(), natural.max(), dom.min(), dom.max());+ let ptol = 1e-9 * 1f64.max((nh.x - nl.x).max(nh.y - nl.y));+ if (nl.x - dl.x).abs() > ptol || (nl.y - dl.y).abs() > ptol || (nh.x - dh.x).abs() > ptol || (nh.y - dh.y).abs() > ptol {+ return Ok(Err(Error::Unsupported));+ }+ let ct = match how {+ Continuation::Tangent => ContinuityType::G1,+ Continuation::Curvature => ContinuityType::G1G2,+ Continuation::Natural => ContinuityType::CInfinity,+ };+ // CreateExtendedSurface takes its distance as an estimate (a natural parabola falls 2.5%+ // short, a G2 run-off of a circle runs more than twice as far): the distance asked of it+ // is solved for until the extension measures `distance` across the side's middle.+ let extended = match extended_by(k, &surf, &dom, grow, ct, distance, model_tol) {+ Ok(e) => e,+ Err(e) => return Ok(Err(e)),+ };+ // A cone or cylinder continued naturally stays one, as the analytic widened, else SMLib+ // gives it back its analytic kind where it can.+ let grown = match how {+ Continuation::Natural => cone_continued(k, &surf, &dom, grow, distance).filter(|g| same_patch(k, g, &extended, 10.0 * model_tol)),+ _ => None,+ };+ let grown = match grown {+ Some(g) => g,+ None => match extended.copy_and_add_analytics(k) {+ Ok(g) => g,+ Err(e) => return Ok(Err(status(e))),+ },+ };+ let bx = grown.natural_uv_domain_with_nurb(k)?;+ let mut r = new_brep(k, USE_DEFAULT, USE_DEFAULT)?;+ r.set_tolerance(b.tolerance());+ let grown_eval = grown.copy(k)?;+ let nf = match build_faces(&mut r, |t, fenv| create_face_from_surface(k, t, Some(grown), &bx, fenv)) {+ Ok(nf) => nf,+ Err(e) => return Ok(Err(status(e))),+ };+ r.refresh_cached_topology();+ // The face and each side stand for the face and side they continue.+ copy_attributes(&b, EntityRef::Face(f), &mut r, EntityRef::Face(nf))?;+ let made = face_p4::edges(&r, nf, None, false, None)?;+ let new_on = 10.0 * r.tolerance().max(1e-9);+ for s in SIDES {+ let from = side_edge(k, &b, &surf, &dom, s, &edges, on);+ let to = side_edge(k, &r, &grown_eval, &bx, s, &made, new_on);+ if let (Some(from), Some(to)) = (from, to) {+ copy_attributes(&b, EntityRef::Edge(from), &mut r, EntityRef::Edge(to))?;+ }+ }+ // The new face faces the way the old one did.+ if let (Some(was), Some(now)) = (upward(&b, f)?, upward(&r, nf)?)+ && was != now+ && let Err(e) = face_p1::flip_face_orientation(&mut r, nf)+ {+ return Ok(Err(status(e)));+ }+ Ok(Ok(r))+ })?+ .map(Body::new)+}++/// A point inside each face, in the body's face order (`smlib_brep_face_points`:+/// `SmFace::CalculateAnInternalPoint`).+pub(crate) fn face_points(body: &Body) -> Result<Vec<[f64; 3]>> {+ super::with_body("smlib_brep_face_points", body, |k, b| {+ let faces = b.face_list().to_vec();+ faces.into_iter().map(|f| face_internal_point(k, b, f).map(|p| [p.x, p.y, p.z])).collect()+ })+}diff --git a/crates/smlib/src/core/trim_tests.rs b/crates/smlib/src/core/trim_tests.rsnew file mode 100644index 0000000000..54f1077ba2--- /dev/null+++ b/crates/smlib/src/core/trim_tests.rs@@ -0,0 +1,429 @@+//! Untrim and extend on solidcore, against closed forms: areas and counts, and every result exports to a+//! record that validates. With SMLib built, the same input converted to the C++ kernel gives the+//! same result or the same error (parity only: the expected values are the analytic ones).+//!+//! An untrim's body is a 20 x 20 x 5 plate with a 3 mm through hole at (10, 10), made on+//! solidcore; its top face is a square with a round hole. An extend's is a one-face sheet that is+//! its surface's whole parameter box: a 10 mm square, or a quarter of a cylinder of radius 10 and+//! height 10.++use std::f64::consts::{FRAC_1_SQRT_2, PI};++use super::trim::{extend_sheet, untrim_face};+use super::{Body, area, counts, make_box, make_cylinder, to_arrays};+use crate::export::native;+use crate::trim::Continuation;+use crate::{BooleanOp, Error};++const TOL: f64 = 0.01;+/// A point on the top face, away from the hole.+const TOP: [f64; 3] = [2.0, 2.0, 5.0];+/// A point on the hole's rim on the top face.+const RIM: [f64; 3] = [13.0, 10.0, 5.0];++/// The plate's top as a sheet of its own: a 20 mm square at z = 0 with a 3 mm hole at (10, 10).+fn holed_sheet() -> Body {+ use crate::sweeps::Curve;+ let line = |a: [f64; 3], b: [f64; 3]| Curve::Line { start: a, end: b };+ let (a, b, c, d) = ([0.0, 0.0, 0.0], [20.0, 0.0, 0.0], [20.0, 20.0, 0.0], [0.0, 20.0, 0.0]);+ let hole = Curve::Arc { center: [10.0, 10.0, 0.0], axis: [0.0, 0.0, 1.0], reference: [1.0, 0.0, 0.0], radius: 3.0, start: 0.0, end: 2.0 * PI };+ super::sweep::planar_faces(&[line(a, b), line(b, c), line(c, d), line(d, a), hole]).unwrap()+}++/// On the sheet: a point away from the hole, and one on the hole's rim.+const SHEET: [f64; 3] = [2.0, 2.0, 0.0];+const SHEET_RIM: [f64; 3] = [13.0, 10.0, 0.0];++#[derive(Clone, Copy, Debug)]+enum Input {+ Plate,+ Sheet,+}++impl Input {+ fn core(self) -> Body {+ match self {+ Input::Plate => plate(),+ Input::Sheet => holed_sheet(),+ }+ }+}++fn plate() -> Body {+ let block = make_box([0.0; 3], [20.0, 20.0, 5.0]).unwrap();+ let pin = make_cylinder([10.0, 10.0, -1.0], 3.0, 7.0).unwrap();+ super::boolean::boolean(&block, &pin, BooleanOp::Subtract).unwrap().unwrap()+}++#[derive(Clone, Copy, Debug)]+struct Case {+ input: Input,+ point: [f64; 3],+ /// `None`: every hole.+ holes: Option<&'static [[f64; 3]]>,+ outer: bool,+ in_place: bool,+}++#[derive(Clone, Debug, PartialEq)]+enum Expect {+ /// A sheet: its area and face count.+ Sheet(f64, usize),+ Fails(Error),+}++fn case(name: &str) -> (Case, Expect) {+ let c = |input, point, holes, outer, in_place| Case { input, point, holes, outer, in_place };+ let square = 400.0;+ let holed = 400.0 - 9.0 * PI;+ let (plate, sheet) = (Input::Plate, Input::Sheet);+ match name {+ // The plate's top face, alone.+ "every_hole_taken_away" => (c(plate, TOP, None, false, false), Expect::Sheet(square, 1)),+ "the_hole_at_a_point_taken_away" => (c(plate, TOP, Some(&[RIM]), false, false), Expect::Sheet(square, 1)),+ // The outer boundary back on the plane's box of the face's span, the hole kept.+ "outer_boundary_back_hole_kept" => (c(plate, TOP, Some(&[]), true, false), Expect::Sheet(holed, 1)),+ "outer_boundary_back_holes_gone" => (c(plate, TOP, None, true, false), Expect::Sheet(square, 1)),+ // In the solid, the hole's edges are the bore's too: no hole of a sheet.+ "a_hole_of_a_solid_in_place" => (c(plate, TOP, None, false, true), Expect::Fails(Error::Unsupported)),+ "a_point_near_no_face" => (c(plate, [50.0, 50.0, 50.0], None, false, false), Expect::Fails(Error::NoMatch { point: 0 })),+ // The holed sheet, in place.+ "sheet_every_hole_taken_away" => (c(sheet, SHEET, None, false, true), Expect::Sheet(square, 1)),+ "sheet_the_hole_at_a_point_taken_away" => (c(sheet, SHEET, Some(&[SHEET_RIM]), false, true), Expect::Sheet(square, 1)),+ "sheet_outer_boundary_back_hole_kept" => (c(sheet, SHEET, Some(&[]), true, true), Expect::Sheet(holed, 1)),+ "sheet_outer_boundary_back_holes_gone" => (c(sheet, SHEET, None, true, true), Expect::Sheet(square, 1)),+ "sheet_a_point_near_no_hole" => (c(sheet, SHEET, Some(&[SHEET]), false, true), Expect::Fails(Error::NoMatch { point: 0 })),+ _ => panic!("no case {name}"),+ }+}++#[derive(Debug, PartialEq)]+struct Measured {+ area: f64,+ counts: [usize; 3],+}++type Got = std::result::Result<Measured, Error>;++fn rel(a: f64, b: f64) -> f64 {+ (a - b).abs() / b.abs()+}++fn judge(name: &str, who: &str, got: Got) -> Got {+ let (_, expect) = case(name);+ match (&expect, &got) {+ (Expect::Fails(e), Err(g)) => assert_eq!(g, e, "{name}: {who} failed otherwise"),+ (Expect::Fails(e), Ok(m)) => panic!("{name}: {who} gave {m:?}, expected {e:?}"),+ (_, Err(g)) => panic!("{name}: {who} failed: {g}"),+ (Expect::Sheet(a, faces), Ok(m)) => {+ assert!(rel(m.area, *a) < 1e-9, "{name}: {who} area {} vs analytic {a}", m.area);+ assert_eq!(m.counts[0], *faces, "{name}: {who} faces");+ }+ }+ got+}++fn solidcore_case(name: &str) -> Got {+ let (c, _) = case(name);+ let got = untrim_face(&c.input.core(), c.point, TOL, c.holes, c.outer, c.in_place).map(|b| {+ let (rec, _) = native(&to_arrays(&b).unwrap()).unwrap_or_else(|e| panic!("{name}: record: {e:?}"));+ rec.validate().unwrap_or_else(|e| panic!("{name}: record: {e}"));+ Measured { area: area(&b, 1e-8).unwrap(), counts: counts(&b).unwrap() }+ });+ judge(name, "solidcore", got)+}++/// The case on the C++ kernel, called directly (whatever the choice), on the plate converted+/// from solidcore's.+#[cfg(feature = "native")]+fn cpp_case(name: &str) -> Got {+ use crate::{Brep, error, ffi};+ crate::init().unwrap();+ let (c, _) = case(name);+ let body = Brep::made_core(c.input.core());+ let r = ffi::trim::untrim_face(body.cpp().unwrap(), &c.point, TOL, c.holes, c.outer, c.in_place).map_err(|s| match s {+ ffi::ops::ERR_PICK_NONE => Error::NoMatch { point: 0 },+ s => error(s),+ });+ let got = r.map(|h| {+ let a = ffi::measure::area(&h, 1e-8).unwrap();+ let n = ffi::counts(&h).unwrap().map(|x| usize::try_from(x).unwrap());+ let (rec, _) = native(&Brep::made(h).cpp_arrays().unwrap()).unwrap();+ rec.validate().unwrap();+ Measured { area: a, counts: n }+ });+ judge(name, "C++", got)+}++#[cfg(feature = "native")]+fn parity(name: &str) {+ match (solidcore_case(name), cpp_case(name)) {+ (Ok(a), Ok(b)) => {+ assert!(rel(a.area, b.area) < 1e-9, "{name}: solidcore {} vs C++ {}", a.area, b.area);+ assert_eq!(a.counts, b.counts, "{name}: counts (solidcore vs C++)");+ }+ (a, b) => assert_eq!(a.err(), b.err(), "{name}: errors (solidcore vs C++)"),+ }+}++macro_rules! cases {+ ($($m:ident $(: $ign:meta)?),* $(,)?) => {$(+ mod $m {+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_closed_form() {+ let _ = super::solidcore_case(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ super::parity(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ fn the_cpp_kernel_matches_the_closed_form() {+ let _cpp = crate::route::on_cpp();+ let _ = super::cpp_case(stringify!($m));+ }+ }+ )*};+}++cases!(+ every_hole_taken_away,+ the_hole_at_a_point_taken_away,+ outer_boundary_back_hole_kept,+ outer_boundary_back_holes_gone,+ a_hole_of_a_solid_in_place,+ a_point_near_no_face,+ sheet_every_hole_taken_away,+ sheet_the_hole_at_a_point_taken_away,+ sheet_outer_boundary_back_hole_kept,+ sheet_outer_boundary_back_holes_gone,+ sheet_a_point_near_no_hole,+);++/// The capi's argument checks, before any kernel call.+#[test]+fn hostile_arguments_are_refused() {+ let b = make_box([0.0; 3], [10.0; 3]).unwrap();+ let p = [5.0, 5.0, 10.0];+ assert_eq!(untrim_face(&b, [f64::NAN, 0.0, 0.0], TOL, None, true, false).err(), Some(Error::Argument));+ for t in [0.0, -1.0, f64::NAN, f64::INFINITY] {+ assert_eq!(untrim_face(&b, p, t, None, true, false).err(), Some(Error::Argument), "tolerance {t}");+ }+ assert_eq!(untrim_face(&b, p, TOL, Some(&[]), false, false).err(), Some(Error::Argument), "nothing to do");+ assert_eq!(untrim_face(&b, p, TOL, Some(&[[f64::INFINITY; 3]]), false, false).err(), Some(Error::Argument));+ let many = vec![p; 10_001];+ assert_eq!(untrim_face(&b, p, TOL, Some(&many), false, false).err(), Some(Error::Argument));+}++/// The body untrimmed is never changed.+#[test]+fn the_body_stays_as_it_was() {+ let b = plate();+ let was = counts(&b).unwrap();+ let _ = untrim_face(&b, TOP, TOL, None, true, false);+ let _ = untrim_face(&b, TOP, TOL, None, false, true);+ assert_eq!(counts(&b).unwrap(), was);+}++/// Face and edge tags (`Brep::tagged`) through an untrim on solidcore, as on C++.+#[cfg(feature = "native")]+mod history {+ use crate::{Brep, ffi};++ #[test]+ fn tags_cross_an_untrim() {+ let _cpp = crate::route::on_cpp();+ crate::init().unwrap();+ let a = Brep::made_core(super::holed_sheet()).tagged(0).unwrap();+ for (holes, outer) in [(None, false), (Some(&[][..]), true)] {+ let cpp = ffi::trim::untrim_face(a.cpp().unwrap(), &super::SHEET, super::TOL, holes, outer, true).unwrap();+ let cpp = Brep::made(cpp).history().unwrap();+ let core = super::untrim_face(a.core().unwrap(), super::SHEET, super::TOL, holes, outer, true).unwrap();+ let core = Brep::made_core(core).history().unwrap();+ assert_eq!(core.canonical(), cpp.canonical(), "holes {holes:?}, outer {outer}");+ }+ }+}++/// A one-face sheet on `surface` over `domain`, the face its whole box.+fn whole_face(surface: solidcore::surface::surface::Surface) -> Body {+ use solidcore::topology::brep::p3::new_brep;+ use solidcore::topology::brep::p8::create_face_from_surface;+ super::run("sheet", |k| {+ let mut b = new_brep(k, solidcore::geom::tol::USE_DEFAULT, solidcore::geom::tol::USE_DEFAULT)?;+ let domain = surface.natural_uv_domain_with_nurb(k)?;+ super::sweep::build_faces(&mut b, |b, fenv| create_face_from_surface(k, b, Some(surface), &domain, fenv))?;+ b.refresh_cached_topology();+ Ok(b)+ })+ .map(Body::new)+ .unwrap()+}++#[derive(Clone, Copy, Debug)]+enum Sheet {+ /// [0, 10]^2 at z = 0.+ Square,+ /// Radius 10 about +Z, from 0 to 90 degrees, z from 0 to 10.+ QuarterCylinder,+}++impl Sheet {+ fn core(self) -> Body {+ use solidcore::geom::extent2d::Extent2d;+ use solidcore::geom::vector2d::Vec2;+ use solidcore::geom::vector3d::Vec3;+ use solidcore::surface::cone::p1::Cone;+ use solidcore::surface::plane::p1::Plane;+ use solidcore::surface::surface::Surface;+ let (o, x, y) = (Vec3::new(0.0, 0.0, 0.0), Vec3::new(1.0, 0.0, 0.0), Vec3::new(0.0, 1.0, 0.0));+ match self {+ Sheet::Square => whole_face(Surface::from(Plane::new(o, x, y, Vec2::new(1.0, 1.0), &Extent2d::from_bounds(0.0, 0.0, 10.0, 10.0)))),+ Sheet::QuarterCylinder => whole_face(Surface::from(Cone::new_cylinder_bounded(o, x, y, 10.0, 0.0, 90.0, 10.0, false, false, false))),+ }+ }+}++fn extend_case(name: &str) -> (Sheet, [f64; 3], f64, Continuation, Expect) {+ let quarter = 5.0 * PI;+ match name {+ "extend_a_square" => (Sheet::Square, [10.0, 5.0, 0.0], 5.0, Continuation::Natural, Expect::Sheet(150.0, 1)),+ "extend_a_square_tangent" => (Sheet::Square, [5.0, 10.0, 0.0], 5.0, Continuation::Tangent, Expect::Sheet(150.0, 1)),+ "extend_a_square_curvature" => (Sheet::Square, [0.0, 5.0, 0.0], 2.0, Continuation::Curvature, Expect::Sheet(120.0, 1)),+ "extend_a_cylinder_along_its_axis" => {+ (Sheet::QuarterCylinder, [FRAC_1_SQRT_2 * 10.0, FRAC_1_SQRT_2 * 10.0, 10.0], 5.0, Continuation::Natural, Expect::Sheet(quarter * 15.0, 1))+ }+ "extend_a_cylinder_round_its_axis" => {+ (Sheet::QuarterCylinder, [10.0, 0.0, 5.0], 5.0, Continuation::Natural, Expect::Sheet(10.0 * (quarter + 5.0), 1))+ }+ // Run-offs 5 long across the surface whatever their curvature: the strip stays its section+ // swept 10 along z. A circle's G2 run-off runs about 2.3 times what it is asked and more+ // than doubles with it (fork 0f7b209), so the ask must be solved for.+ "extend_a_cylinder_tangent_run_off" => {+ (Sheet::QuarterCylinder, [10.0, 0.0, 5.0], 5.0, Continuation::Tangent, Expect::Sheet(10.0 * (quarter + 5.0), 1))+ }+ "extend_a_cylinder_curvature_run_off" => {+ (Sheet::QuarterCylinder, [10.0, 0.0, 5.0], 5.0, Continuation::Curvature, Expect::Sheet(10.0 * (quarter + 5.0), 1))+ }+ "extend_picks_near_no_edge" => (Sheet::Square, [50.0, 50.0, 0.0], 5.0, Continuation::Natural, Expect::Fails(Error::NoMatch { point: 0 })),+ _ => panic!("no case {name}"),+ }+}++fn extend_judge(name: &str, who: &str, got: Got) -> Got {+ let (.., expect) = extend_case(name);+ match (&expect, &got) {+ (Expect::Fails(e), Err(g)) => assert_eq!(g, e, "{name}: {who} failed otherwise"),+ (Expect::Fails(e), Ok(m)) => panic!("{name}: {who} gave {m:?}, expected {e:?}"),+ (_, Err(g)) => panic!("{name}: {who} failed: {g}"),+ (Expect::Sheet(a, faces), Ok(m)) => {+ assert!(rel(m.area, *a) < 1e-6, "{name}: {who} area {} vs analytic {a}", m.area);+ assert_eq!(m.counts[0], *faces, "{name}: {who} faces");+ }+ }+ got+}++fn extend_solidcore(name: &str) -> Got {+ let (sheet, point, distance, how, _) = extend_case(name);+ let got = extend_sheet(&sheet.core(), point, TOL, distance, how).map(|b| {+ let (rec, _) = native(&to_arrays(&b).unwrap()).unwrap_or_else(|e| panic!("{name}: record: {e:?}"));+ rec.validate().unwrap_or_else(|e| panic!("{name}: record: {e}"));+ Measured { area: area(&b, 1e-8).unwrap(), counts: counts(&b).unwrap() }+ });+ extend_judge(name, "solidcore", got)+}++#[cfg(feature = "native")]+fn extend_cpp(name: &str) -> Got {+ use crate::{Brep, error, ffi};+ crate::init().unwrap();+ let (sheet, point, distance, how, _) = extend_case(name);+ let mode = match how {+ Continuation::Natural => ffi::trim::EXTEND_NATURAL,+ Continuation::Tangent => ffi::trim::EXTEND_TANGENT,+ Continuation::Curvature => ffi::trim::EXTEND_CURVATURE,+ };+ let body = Brep::made_core(sheet.core());+ let r = ffi::trim::extend_sheet(body.cpp().unwrap(), &point, TOL, distance, mode).map_err(|s| match s {+ ffi::ops::ERR_PICK_NONE => Error::NoMatch { point: 0 },+ s => error(s),+ });+ let got = r.map(|h| {+ let a = ffi::measure::area(&h, 1e-8).unwrap();+ let n = ffi::counts(&h).unwrap().map(|x| usize::try_from(x).unwrap());+ let (rec, _) = native(&Brep::made(h).cpp_arrays().unwrap()).unwrap();+ rec.validate().unwrap();+ Measured { area: a, counts: n }+ });+ extend_judge(name, "C++", got)+}++#[cfg(feature = "native")]+fn extend_parity(name: &str) {+ match (extend_solidcore(name), extend_cpp(name)) {+ (Ok(a), Ok(b)) => {+ assert!(rel(a.area, b.area) < 1e-9, "{name}: solidcore {} vs C++ {}", a.area, b.area);+ assert_eq!(a.counts, b.counts, "{name}: counts (solidcore vs C++)");+ }+ (a, b) => assert_eq!(a.err(), b.err(), "{name}: errors (solidcore vs C++)"),+ }+}++macro_rules! extend_cases {+ ($($m:ident $(: $ign:meta)?),* $(,)?) => {$(+ mod $m {+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_closed_form() {+ let _ = super::extend_solidcore(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ $(#[$ign])?+ fn solidcore_matches_the_cpp_kernel() {+ let _cpp = crate::route::on_cpp();+ super::extend_parity(stringify!($m));+ }+ #[cfg(feature = "native")]+ #[test]+ fn the_cpp_kernel_matches_the_closed_form() {+ let _cpp = crate::route::on_cpp();+ let _ = super::extend_cpp(stringify!($m));+ }+ }+ )*};+}++extend_cases!(+ extend_a_square,+ extend_a_square_tangent,+ extend_a_square_curvature,+ extend_a_cylinder_along_its_axis,+ extend_a_cylinder_round_its_axis,+ extend_a_cylinder_tangent_run_off,+ extend_a_cylinder_curvature_run_off,+ extend_picks_near_no_edge,+);++/// The capi's argument checks for an extend, before any kernel call, and a body of more than+/// one face.+#[test]+fn hostile_extend_arguments_are_refused() {+ let s = Sheet::Square.core();+ let p = [10.0, 5.0, 0.0];+ assert_eq!(extend_sheet(&s, [f64::NAN; 3], TOL, 5.0, Continuation::Natural).err(), Some(Error::Argument));+ for t in [0.0, -1.0, f64::NAN, f64::INFINITY] {+ assert_eq!(extend_sheet(&s, p, t, 5.0, Continuation::Natural).err(), Some(Error::Argument), "tolerance {t}");+ assert_eq!(extend_sheet(&s, p, TOL, t, Continuation::Natural).err(), Some(Error::Argument), "distance {t}");+ }+ let cube = make_box([0.0; 3], [10.0; 3]).unwrap();+ assert_eq!(extend_sheet(&cube, p, TOL, 5.0, Continuation::Natural).err(), Some(Error::Unsupported));+ // A face that is not its surface's whole box: a square with a hole.+ assert_eq!(extend_sheet(&holed_sheet(), [20.0, 5.0, 0.0], TOL, 5.0, Continuation::Natural).err(), Some(Error::Unsupported));+}diff --git a/crates/smlib/src/export.rs b/crates/smlib/src/export.rsindex 78910c80c8..bf085c6d47 100644--- a/crates/smlib/src/export.rs+++ b/crates/smlib/src/export.rs@@ -50,37 +50,59 @@ use crate::{Brep, Result, error, ffi, init};impl Brep {/// A cylinder about +Z: base centre, radius and height (mm, > 0).pub fn make_cylinder(origin: [f64; 3], radius: f64, height: f64) -> Result<Brep> {+ if crate::route::backend() == crate::route::Backend::Solidcore {+ return crate::core::make_cylinder(origin, radius, height).map(Brep::made_core);+ }init()?;- ffi::make_cylinder(&origin, radius, height).map(Brep).map_err(error)+ ffi::make_cylinder(&origin, radius, height).map(Brep::made).map_err(error)}/// A sphere: centre and radius (mm, > 0).pub fn make_sphere(center: [f64; 3], radius: f64) -> Result<Brep> {+ if crate::route::backend() == crate::route::Backend::Solidcore {+ return crate::core::make_sphere(center, radius).map(Brep::made_core);+ }init()?;- ffi::make_sphere(¢er, radius).map(Brep).map_err(error)+ ffi::make_sphere(¢er, radius).map(Brep::made).map_err(error)}/// A cone or frustum about +Z: base centre, base radius (> 0), top radius (≥ 0, not the base/// radius) and height (> 0), in mm.pub fn make_cone(origin: [f64; 3], base_radius: f64, top_radius: f64, height: f64) -> Result<Brep> {+ if crate::route::backend() == crate::route::Backend::Solidcore {+ return crate::core::make_cone(origin, base_radius, top_radius, height).map(Brep::made_core);+ }init()?;- ffi::make_cone(&origin, base_radius, top_radius, height).map(Brep).map_err(error)+ ffi::make_cone(&origin, base_radius, top_radius, height).map(Brep::made).map_err(error)}/// A ring torus about +Z: centre, major radius > minor radius > 0 (mm).pub fn make_torus(center: [f64; 3], major_radius: f64, minor_radius: f64) -> Result<Brep> {+ if crate::route::backend() == crate::route::Backend::Solidcore {+ return crate::core::make_torus(center, major_radius, minor_radius).map(Brep::made_core);+ }init()?;- ffi::make_torus(¢er, major_radius, minor_radius).map(Brep).map_err(error)+ ffi::make_torus(¢er, major_radius, minor_radius).map(Brep::made).map_err(error)}- /// The flat arrays of this body that the mapping reads ([`Brep::export`]), copied out.+ /// The flat arrays of this body that the mapping reads, from the kernel in force+ /// ([`crate::route::backend`]).pub fn arrays(&self) -> Result<Arrays> {+ match crate::route::backend() {+ crate::route::Backend::Smlib => self.cpp_arrays(),+ crate::route::Backend::Solidcore => crate::core::to_arrays(self.core()?),+ }+ }++ /// The flat arrays of the C++ kernel's body ([`Brep::export`]), every one copied out: the+ /// mapping reads some, solidcore's import ([`crate::core::from_arrays`]) all of them.+ pub(crate) fn cpp_arrays(&self) -> Result<Arrays> {let f = self.export()?;let mut out = Arrays::default();- for &id in I64_IDS {+ for id in REGION_SHELL_COUNT..=FACE_DEFINITION_REAL_COUNT {out.ints.insert(id, f.get_i64(id)?);}- for &id in F64_IDS {+ for id in TOLERANCE..=FACE_DEFINITION_REALS {out.reals.insert(id, f.get_f64(id)?);}Ok(out)@@ -150,92 +172,6 @@ fn unsupported(what: impl std::fmt::Display) -> ExportError {// ---- The arrays (ids and kinds from `crate::flat`, as in capi/include/smlib.h) -------------/// The int64 arrays this mapping reads.-const I64_IDS: &[i32] = &[- REGION_SHELL_COUNT,- REGION_TYPE,- SHELL_FACEUSE_COUNT,- SHELL_WIRE_EDGE_COUNT,- SHELL_POINT_TYPE,- FACEUSE_FACE,- FACEUSE_ORIENTATION,- FACE_LOOP_COUNT,- FACE_SURFACE_TYPE,- LOOP_EDGEUSE_COUNT,- LOOP_VERTEX,- EDGEUSE_EDGE,- EDGEUSE_ORIENTATION,- EDGEUSE_NEXT_RADIAL,- EDGEUSE_RADIAL_ENTRY,- EDGEUSE_NURBS_VERTEX_COUNT,- EDGEUSE_NURBS_ORDER,- EDGE_CURVE_TYPE,- EDGE_VERTICES,- EDGE_NURBS_VERTEX_COUNT,- EDGE_NURBS_ORDER,- FACE_NURBS_U_VERTEX_COUNT,- FACE_NURBS_V_VERTEX_COUNT,- FACE_NURBS_U_ORDER,- FACE_NURBS_V_ORDER,- FACE_NURBS_FORM,- EDGE_NURBS_FORM,- FACE_DEFINITION_REAL_COUNT,-];--/// The double arrays this mapping reads.-const F64_IDS: &[i32] = &[- TOLERANCE,- EXTENT,- FACE_RANGE,- EDGE_RANGE,- VERTEX_POSITION,- EDGE_NURBS_CVS,- EDGE_NURBS_KNOTS,- EDGE_NURBS_WEIGHTS,- EDGE_CIRCLE_CENTER,- EDGE_CIRCLE_AXIS,- EDGE_CIRCLE_REF_DIRECTION,- EDGE_CIRCLE_RADIUS,- EDGE_LINE_ORIGIN,- EDGE_LINE_DIRECTION,- EDGE_ELLIPSE_CENTER,- EDGE_ELLIPSE_AXIS,- EDGE_ELLIPSE_REF_DIRECTION,- EDGE_ELLIPSE_X_RADIUS,- EDGE_ELLIPSE_Y_RADIUS,- EDGEUSE_NURBS_CVS,- EDGEUSE_NURBS_KNOTS,- EDGEUSE_NURBS_WEIGHTS,- FACE_NURBS_CVS,- FACE_NURBS_U_KNOTS,- FACE_NURBS_V_KNOTS,- FACE_NURBS_WEIGHTS,- FACE_SPHERE_CENTER,- FACE_SPHERE_AXIS,- FACE_SPHERE_REF_DIRECTION,- FACE_SPHERE_RADIUS,- FACE_PLANE_ORIGIN,- FACE_PLANE_AXIS,- FACE_PLANE_REF_DIRECTION,- FACE_CYLINDER_ORIGIN,- FACE_CYLINDER_AXIS,- FACE_CYLINDER_REF_DIRECTION,- FACE_CYLINDER_RADIUS,- FACE_CONE_ORIGIN,- FACE_CONE_AXIS,- FACE_CONE_REF_DIRECTION,- FACE_CONE_RADIUS,- FACE_CONE_SEMI_ANGLE,- FACE_TORUS_ORIGIN,- FACE_TORUS_AXIS,- FACE_TORUS_REF_DIRECTION,- FACE_TORUS_MAJOR_RADIUS,- FACE_TORUS_MINOR_RADIUS,- EDGE_TOLERANCE,- VERTEX_TOLERANCE,- FACE_DEFINITION_REALS,-];-// The kind values as the arrays hold them (int64); a local item shadows the glob import.const SURFACE_NURBS: i64 = flat::SURFACE_NURBS as i64;const SURFACE_PLANE: i64 = flat::SURFACE_PLANE as i64;@@ -384,8 +320,9 @@ fn surfaces(flat: View, n_faces: usize) -> Res<Vec<(b::Surface, Option<b::Surfacv3(flat.f(FACE_CONE_REF_DIRECTION), i, "cone")?,);let (radius, half) = (at(flat.f(FACE_CONE_RADIUS), i, "cone")?, at(flat.f(FACE_CONE_SEMI_ANGLE), i, "cone")?);- // SMLib's cone of semi-angle 0 is its cylinder.- if half == 0.0 {+ // SMLib's cone of semi-angle 0 is its cylinder, and one within rounding of it (a thread's+ // cone of 1e-13 comes out of the trims) is too: the portable record refuses it as a cone.+ if half.abs() < 1e-12 {b::Surface::Cylinder { frame: f, radius }} else {b::Surface::Cone { frame: f, radius_at_origin: radius, half_angle: half }diff --git a/crates/smlib/src/export/tests.rs b/crates/smlib/src/export/tests.rsindex 2146e40122..0b767d090a 100644--- a/crates/smlib/src/export/tests.rs+++ b/crates/smlib/src/export/tests.rs@@ -174,6 +174,16 @@ mod native_tests {assert!((half.unwrap() + 0.5f64.atan()).abs() < 1e-12);}+ /// A cone whose half angle is within rounding of zero (a52's thread bosses: 1e-13) is exported as+ /// a cylinder; as a cone the portable record's validation refuses it.+ #[test]+ fn a_cone_of_rounding_angle_is_exported_as_a_cylinder() {+ let near = Brep::make_cone([0.0; 3], 4.0, 4.0 - 1e-12, 10.0).unwrap().to_native().unwrap();+ assert!(near.faces.iter().any(|f| matches!(f.surface, b::Surface::Cylinder { .. })));+ assert!(!near.faces.iter().any(|f| matches!(f.surface, b::Surface::Cone { .. })));+ near.validate().unwrap();+ }+/// A hole tangent to the block's outline from inside: the material touches itself along the/// tangent line, where SMLib's one shell uses the edge four times. The record has two copies/// of that edge, each bounding one wedge of material (a face of the side and the half of thediff --git a/crates/smlib/src/flat.rs b/crates/smlib/src/flat.rsindex 0160bf3933..f7bcdf8005 100644--- a/crates/smlib/src/flat.rs+++ b/crates/smlib/src/flat.rs@@ -39,6 +39,7 @@ pub const FACE_NURBS_V_ORDER: i32 = 31;pub const SOURCE: i32 = 32;pub const FACE_NURBS_FORM: i32 = 33;pub const EDGE_NURBS_FORM: i32 = 34;+pub const WIRE_EDGE_NURBS_FORM: i32 = 35;/// Per face whose kind carries a definition (a ball patch), in face order: how many reals of/// `FACE_DEFINITION_REALS` are its definition (a ball patch: 4).pub const FACE_DEFINITION_REAL_COUNT: i32 = 36;@@ -172,18 +173,21 @@ impl Flat {/// The SMLib B-rep these arrays describe (checked on the C side before SMLib sees them).pub fn import(&self) -> Result<Brep> {init()?;- ffi::flat::import(&self.0).map(Brep).map_err(error)+ ffi::flat::import(&self.0).map(Brep::made).map_err(error)}}impl Brep {/// This body as flat arrays.pub fn export(&self) -> Result<Flat> {- ffi::flat::export(&self.0).map(Flat).map_err(error)+ ffi::flat::export(self.cpp()?).map(Flat).map_err(error)}/// Whether SMLib finds this body one closed, manifold solid.pub fn is_manifold_solid(&self) -> Result<bool> {- ffi::flat::is_manifold_solid(&self.0).map_err(error)+ if crate::route::backend() == crate::route::Backend::Solidcore {+ return crate::core::is_manifold_solid(self.core()?);+ }+ ffi::flat::is_manifold_solid(self.cpp()?).map_err(error)}}diff --git a/crates/smlib/src/history.rs b/crates/smlib/src/history.rsindex e2eedc1640..bee815bfec 100644--- a/crates/smlib/src/history.rs+++ b/crates/smlib/src/history.rs@@ -14,7 +14,7 @@ use std::collections::BTreeSet;use solidcraft_geom::brep::history::{Change, EdgeOrigin, EdgeProv, FaceOrigin, FaceProv, Failed, History, Side};-use crate::{Brep, Error, Result, error, ffi};+use crate::{Brep, Error, Result, core, error, ffi, route};/// A result face as SMLib reports it: how it relates to its origins, and the (operand, face)/// pairs it came from, sorted.@@ -67,20 +67,62 @@ impl Brep {/// A copy whose face i and edge i are tagged as face i and edge i of operand `operand` (in/// SMLib's order, which the copy keeps). Run an operation on tagged copies, then read its/// result's [`Brep::history`].+ ///+ /// The tags are made in the kernel the body is in (solidcore's when it has its body,+ /// [`crate::core::history`]); converted for the other, the body is tagged there the same way.pub fn tagged(&self, operand: usize) -> Result<Brep> {- let operand = i32::try_from(operand).map_err(|_| Error::Argument)?;- ffi::history::tag(&self.0, operand).map(Brep).map_err(error)+ let mut t = match self.core.get() {+ Some(Ok(b)) => Brep::made_core(core::history::tag(b, operand)?),+ _ => {+ let k = i32::try_from(operand).map_err(|_| Error::Argument)?;+ Brep::made(ffi::history::tag(self.cpp()?, k).map_err(error)?)+ }+ };+ t.operand = Some(operand);+ Ok(t)}/// The history of this body, made by an operation from tagged operands: each face's and- /// edge's origins among them. Faces and edges no tag reached have none.+ /// edge's origins among them. Faces and edges no tag reached have none. Read in the kernel+ /// that made the body: the tags never cross between them.pub fn history(&self) -> Result<Raw> {- let v = ffi::history::read(&self.0).map_err(error)?;+ if self.maker == route::Backend::Solidcore {+ return core::history::read(self.core()?);+ }+ let v = ffi::history::read(self.cpp()?).map_err(error)?;Raw::decode(&v).ok_or(Error::Exception)}}impl Raw {+ /// This history with its faces in a canonical order (by origins, then change) and each edge+ /// naming its faces by that order, the edges sorted: two kernels' histories of one result+ /// compare equal whatever order each lists its faces and edges in.+ #[cfg(all(test, feature = "native"))]+ pub(crate) fn canonical(&self) -> Raw {+ let mut order: Vec<usize> = (0..self.faces.len()).collect();+ order.sort_by(|a, b| {+ let (fa, fb) = (&self.faces[*a], &self.faces[*b]);+ (&fa.origins, fa.change as u8).cmp(&(&fb.origins, fb.change as u8))+ });+ let mut at = vec![0; order.len()];+ for (new, old) in order.iter().enumerate() {+ at[*old] = new;+ }+ let faces = order.iter().map(|i| self.faces[*i].clone()).collect();+ let mut edges: Vec<RawEdge> = self+ .edges+ .iter()+ .map(|e| {+ let mut f: Vec<usize> = e.faces.iter().map(|i| at[*i]).collect();+ f.sort();+ RawEdge { faces: f, origins: e.origins.clone() }+ })+ .collect();+ edges.sort_by(|a, b| (&a.origins, &a.faces).cmp(&(&b.origins, &b.faces)));+ Raw { faces, edges }+ }+/// Decodes `smlib_history_read`'s records; `None` where they don't read as its layout.fn decode(v: &[i64]) -> Option<Raw> {let mut r = Reader(v.iter());diff --git a/crates/smlib/src/import.rs b/crates/smlib/src/import.rsindex efd0fe1d84..aa346229c9 100644--- a/crates/smlib/src/import.rs+++ b/crates/smlib/src/import.rs@@ -666,15 +666,23 @@ mod analytic;mod tests;impl crate::Brep {+ /// A body of the kernel in force ([`crate::route::backend`]), from flat arrays.+ pub(crate) fn from_arrays(a: &Arrays) -> crate::Result<crate::Brep> {+ match crate::route::backend() {+ crate::route::Backend::Smlib => crate::flat::Flat::from_arrays(a)?.import(),+ crate::route::Backend::Solidcore => crate::core::from_arrays(a).map(crate::Brep::made_core),+ }+ }+/// The SMLib B-rep of a schema 4 record. `trusted` as in [`arrays`].pub fn from_record(brep: &b::Brep, trusted: bool) -> crate::Result<crate::Brep> {let a = arrays(brep, trusted).map_err(crate::Error::Record)?;- crate::flat::Flat::from_arrays(&a)?.import()+ crate::Brep::from_arrays(&a)}/// [`crate::Brep::from_record`] through [`arrays_keeping_splines`].pub fn from_record_keeping_splines(brep: &b::Brep, trusted: bool) -> crate::Result<crate::Brep> {let a = arrays_keeping_splines(brep, trusted).map_err(crate::Error::Record)?;- crate::flat::Flat::from_arrays(&a)?.import()+ crate::Brep::from_arrays(&a)}}diff --git a/crates/smlib/src/lib.rs b/crates/smlib/src/lib.rsindex 8a63fb7b8b..213ac9708c 100644--- a/crates/smlib/src/lib.rs+++ b/crates/smlib/src/lib.rs@@ -6,16 +6,19 @@//! the handles, turns status codes into [`Error`], and sends SMLib's one-line-per-call log to the//! `log` crate (target `smlib`).//!-//! Built without the `native` feature, the crate needs no C++ toolchain and every call returns-//! [`Error::NotBuilt`].+//! The `native` feature (the apps' `smlib`, off by default) compiles and links the C++ kernel.+//! Without it the crate needs no C++ toolchain, no SMLib sources and no prebuilt library: solidcore+//! answers every operation, and asking for the C++ kernel (`SOLIDCRAFT_KERNEL=smlib`) makes every+//! call that would reach it return [`Error::NotBuilt`], never the other kernel's answer.#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]use std::ffi::CString;use std::path::Path;-use std::sync::Once;use std::sync::atomic::{AtomicI32, Ordering};+use std::sync::{Once, OnceLock};mod check;+mod core;pub mod export;mod ffi;pub mod flat;@@ -24,6 +27,7 @@ pub mod import;mod measure;mod ops;pub mod pcurves;+pub mod route;mod sheets;mod split;pub mod ssi;@@ -75,10 +79,18 @@ pub enum Error {Exception,/// The C API is a different version from the one this crate was written against.Version(i32),- /// This build has no SMLib (the `native` feature is off).+ /// The C++ kernel was asked for on a build without it (the `native` feature, which the apps'+ /// `smlib` feature turns on, is off): [`NOT_BUILT`].NotBuilt,/// A B-rep record SMLib cannot take (see [`import::Unsupported`]).Record(import::Unsupported),+ /// solidcore reported an error (the call, then its message).+ Solidcore(String),+ /// solidcore panicked; the guard caught it (the call, then the panic's message).+ Internal(String),+ /// A step of the C++ kernel solidcore has not ported yet, refused rather than built another+ /// way: what is missing, and the solidcore issue that ports it.+ Unported(&'static str),}impl std::fmt::Display for Error {@@ -114,8 +126,11 @@ impl std::fmt::Display for Error {}Error::Exception => write!(f, "SMLib raised an internal exception"),Error::Version(v) => write!(f, "SMLib C API version {v}, expected {}", ffi::ABI_VERSION),- Error::NotBuilt => write!(f, "not supported yet: this build has no SMLib"),+ Error::NotBuilt => write!(f, "{NOT_BUILT}"),Error::Record(u) => write!(f, "{u}"),+ Error::Solidcore(e) => write!(f, "solidcore: {e}"),+ Error::Internal(e) => write!(f, "solidcore failed internally in {e}"),+ Error::Unported(what) => write!(f, "not supported yet: {what}"),}}}@@ -124,6 +139,14 @@ impl std::error::Error for Error {}pub type Result<T> = std::result::Result<T, Error>;+/// What [`Error::NotBuilt`] says: the C++ kernel is opt-in at build time, and how to opt in.+pub const NOT_BUILT: &str = "this build doesn't include the C++ SMLib kernel; build with --features smlib";++/// Whether this build links the C++ SMLib kernel (the `native` feature).+pub const fn built() -> bool {+ cfg!(feature = "native")+}+fn error(s: i32) -> Error {match s {ffi::ERR_ARG | ffi::ERR_BUFFER => Error::Argument,@@ -182,6 +205,8 @@ static INIT_RESULT: AtomicI32 = AtomicI32::new(0);/// Checks the C API's version, creates SMLib's context and routes its log to the `log` crate./// Every other call runs it first; calling it at start-up keeps the cost out of the first operation.pub fn init() -> Result<()> {+ #[cfg(test)]+ route::reached_cpp();INIT.call_once(|| {let v = ffi::abi_version();let result = if v == ffi::NOT_BUILT {@@ -201,24 +226,51 @@ pub fn init() -> Result<()> {}}-/// Where failing calls leave their inputs for replay (see the C API's `smlib_set_dump_dir`);-/// `None` turns that off.+/// Where failing calls leave their inputs for replay, on either kernel (see the C API's+/// `smlib_set_dump_dir`); `None` turns that off. A build without the C++ kernel has only solidcore's.pub fn set_dump_dir(dir: Option<&Path>) -> Result<()> {- init()?;let c = dir.map(c_path).transpose()?;- check(ffi::set_dump_dir(c.as_deref()))+ core::dump::set_dir(dir.map(Path::to_path_buf));+ // A build or a run on solidcore alone never starts the C++ kernel to tell it.+ if route::backend() != route::Backend::Smlib {+ return Ok(());+ }+ match init() {+ Ok(()) => check(ffi::set_dump_dir(c.as_deref())),+ Err(Error::NotBuilt) => Ok(()),+ Err(e) => Err(e),+ }}-/// The SMLib call running right now, if any: for crash reports. Takes no lock.+/// The kernel call running right now, on either kernel, if any: for crash reports. Takes no lock.pub fn current_call() -> Option<String> {+ if let Some(call) = core::dump::current() {+ return Some(call);+ }+ if route::backend() != route::Backend::Smlib {+ return None;+ }let mut buf = [0u8; 512];let n = ffi::current_call(&mut buf);let s = buf.get(..n).map(|b| String::from_utf8_lossy(b).into_owned()).unwrap_or_default();(!s.is_empty()).then_some(s)}-/// An SMLib B-rep. Immutable: operations return new bodies.-pub struct Brep(ffi::Handle);+/// A B-rep in either kernel ([`route`]). Immutable: operations return new bodies. A body made+/// by one kernel is converted for the other the first time an operation there needs it, through the+/// flat arrays both understand, and keeps both. A process has one kernel at a time, and this stays+/// because that kernel can change under a live body: changing the preference or `diagnostics.kernel`+/// leaves bodies already computed as they are, so the next operation on one needs it on the new+/// kernel. The parity tests take solidcore's bodies to the C++ kernel the same way.+pub struct Brep {+ cpp: OnceLock<Result<ffi::Handle>>,+ core: OnceLock<Result<core::Body>>,+ /// The kernel that made it, whose tags [`Brep::history`] reads (the arrays carry none).+ maker: route::Backend,+ /// `Some(k)` for [`Brep::tagged`]`(k)`: its faces and edges stand for their own positions in+ /// operand `k`, so the body converted for the other kernel is tagged the same way there.+ operand: Option<usize>,+}impl std::fmt::Debug for Brep {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {@@ -227,26 +279,83 @@ impl std::fmt::Debug for Brep {}impl Brep {+ /// A body the C++ kernel made.+ fn made(h: ffi::Handle) -> Brep {+ #[cfg(test)]+ route::reached_cpp();+ Brep { cpp: OnceLock::from(Ok(h)), core: OnceLock::new(), maker: route::Backend::Smlib, operand: None }+ }++ /// A body solidcore made.+ fn made_core(b: core::Body) -> Brep {+ Brep { cpp: OnceLock::new(), core: OnceLock::from(Ok(b)), maker: route::Backend::Solidcore, operand: None }+ }++ /// The C++ kernel's body: converted from solidcore's the first time it is asked for (and+ /// tagged as solidcore's is, for a [`Brep::tagged`] body).+ fn cpp(&self) -> Result<&ffi::Handle> {+ #[cfg(test)]+ route::reached_cpp();+ let made = self.cpp.get_or_init(|| {+ let core = self.core.get().ok_or(Error::Empty)?.as_ref().map_err(Clone::clone)?;+ let a = core::to_arrays(core)?;+ let h = flat::Flat::from_arrays(&a)?.import()?.cpp.into_inner().unwrap_or(Err(Error::Empty))?;+ match self.operand {+ Some(k) => ffi::history::tag(&h, i32::try_from(k).map_err(|_| Error::Argument)?).map_err(error),+ None => Ok(h),+ }+ });+ made.as_ref().map_err(Clone::clone)+ }++ /// solidcore's body: converted from the C++ kernel's the first time it is asked for (and+ /// tagged as the C++ kernel's is, for a [`Brep::tagged`] body).+ fn core(&self) -> Result<&core::Body> {+ let made = self.core.get_or_init(|| {+ self.cpp.get().ok_or(Error::Empty)?.as_ref().map_err(Clone::clone)?;+ let b = core::from_arrays(&self.cpp_arrays()?)?;+ match self.operand {+ Some(k) => core::history::tag(&b, k),+ None => Ok(b),+ }+ });+ made.as_ref().map_err(Clone::clone)+ }+/// An axis-aligned box from its lower corner, with positive edge lengths (mm).pub fn make_box(origin: [f64; 3], size: [f64; 3]) -> Result<Brep> {+ if route::backend() == route::Backend::Solidcore {+ return core::make_box(origin, size).map(Brep::made_core);+ }init()?;- ffi::make_box(&origin, &size).map(Brep).map_err(error)+ ffi::make_box(&origin, &size).map(Brep::made).map_err(error)}/// Reads a native SMLib `.smb` file.pub fn read(path: &Path, ascii: bool) -> Result<Brep> {+ if route::backend() == route::Backend::Solidcore {+ c_path(path)?;+ return core::file::read(path, ascii).map(Brep::made_core);+ }init()?;- ffi::read(&c_path(path)?, ascii).map(Brep).map_err(error)+ ffi::read(&c_path(path)?, ascii).map(Brep::made).map_err(error)}/// Writes this body to a native SMLib `.smb` file.pub fn write(&self, path: &Path, ascii: bool) -> Result<()> {- check(ffi::write(&self.0, &c_path(path)?, ascii))+ if route::backend() == route::Backend::Solidcore {+ c_path(path)?;+ return core::file::write(self.core()?, path, ascii);+ }+ check(ffi::write(self.cpp()?, &c_path(path)?, ascii))}/// A deep copy.pub fn try_clone(&self) -> Result<Brep> {- ffi::copy(&self.0).map(Brep).map_err(error)+ if route::backend() == route::Backend::Solidcore {+ return core::transform::copy(self.core()?).map(Brep::made_core);+ }+ ffi::copy(self.cpp()?).map(Brep::made).map_err(error)}/// This body moved by the affine `matrix` (column-major: columns 0–2 the images of x, y and@@ -254,17 +363,26 @@ impl Brep {/// mirror it, a non-uniform scale or a shear turns its geometry into NURBS, tolerances scale/// with it.pub fn transformed(&self, matrix: &[[f64; 4]; 4]) -> Result<Brep> {- ffi::transform(&self.0, matrix).map(Brep).map_err(error)+ if route::backend() == route::Backend::Solidcore {+ return core::transform::transform(self.core()?, matrix).map(Brep::made_core);+ }+ ffi::transform(self.cpp()?, matrix).map(Brep::made).map_err(error)}/// The enclosed volume (mm³) at `relative_accuracy` (SMLib clamps it to [1e-8, 1e-1]).pub fn volume(&self, relative_accuracy: f64) -> Result<f64> {- ffi::volume(&self.0, relative_accuracy).map_err(error)+ if route::backend() == route::Backend::Solidcore {+ return core::volume(self.core()?, relative_accuracy);+ }+ ffi::volume(self.cpp()?, relative_accuracy).map_err(error)}/// Face, edge and vertex counts.pub fn counts(&self) -> Result<[usize; 3]> {- let c = ffi::counts(&self.0).map_err(error)?;+ if route::backend() == route::Backend::Solidcore {+ return core::counts(self.core()?);+ }+ let c = ffi::counts(self.cpp()?).map_err(error)?;Ok(c.map(|n| usize::try_from(n).unwrap_or(0)))}}diff --git a/crates/smlib/src/measure.rs b/crates/smlib/src/measure.rsindex 0509539f86..0a878ec562 100644--- a/crates/smlib/src/measure.rs+++ b/crates/smlib/src/measure.rs@@ -2,7 +2,12 @@//! surfaces rather than a tessellation; the exact box; how far an edge lies from a face's surface;//! where a point lies against a body.-use crate::{Brep, Result, error, ffi};+use crate::{Brep, Result, core, error, ffi, route};++/// Whether the Measure family runs on solidcore ([`route`]).+fn on_core() -> bool {+ route::backend() == route::Backend::Solidcore+}/// The accuracy [`Brep::mass_properties`] and [`Brep::area`] use unless told otherwise: the/// finest SMLib allows. Analytic primitives then come out within 2e-7 of their closed forms.@@ -50,7 +55,10 @@ impl Brep {/// else inside a material region or outside. A body with no material (a sheet, an open shell)/// has no inside. A non-finite coordinate is [`Error::Argument`](crate::Error::Argument).pub fn classify_point(&self, p: [f64; 3]) -> Result<PointClass> {- match ffi::measure::classify_point(&self.0, p).map_err(error)? {+ if on_core() {+ return core::classify_point(self.core()?, p);+ }+ match ffi::measure::classify_point(self.cpp()?, p).map_err(error)? {ffi::measure::POINT_OUTSIDE => Ok(PointClass::Outside),ffi::measure::POINT_INSIDE => Ok(PointClass::Inside),ffi::measure::POINT_ON_BOUNDARY => Ok(PointClass::OnBoundary),@@ -64,7 +72,10 @@ impl Brep {/// touching along edges or at points, measure too. A body with no material (a sheet, an open/// shell) has volume 0 and no inertia, its faces' area and the centroid of that area.pub fn mass_properties(&self, relative_accuracy: f64) -> Result<MassProperties> {- let m = ffi::measure::mass_properties(&self.0, relative_accuracy).map_err(error)?;+ if on_core() {+ return core::mass_properties(self.core()?, relative_accuracy);+ }+ let m = ffi::measure::mass_properties(self.cpp()?, relative_accuracy).map_err(error)?;let [area, volume, cx, cy, cz, ixx, iyy, izz, iyz, izx, ixy] = m;Ok(MassProperties { area, volume, centroid: [cx, cy, cz], moments: [ixx, iyy, izz], products: [iyz, izx, ixy] })}@@ -72,7 +83,10 @@ impl Brep {/// The exact axis-aligned box, least corner then greatest: the extrema of every vertex, edge/// and face on its exact curve or surface, not grown by tolerances or control hulls.pub fn bounds(&self) -> Result<([f64; 3], [f64; 3])> {- ffi::measure::bounds(&self.0).map_err(error)+ if on_core() {+ return core::bounds(self.core()?);+ }+ ffi::measure::bounds(self.cpp()?).map_err(error)}/// How far edge `edge` (its curve over its interval) lies from the surface of face `face`,@@ -82,13 +96,113 @@ impl Brep {/// goes; SMLib keeps such an edge whole when making its UV trim only when its zone tolerance/// (half the flat arrays' `EDGE_TOLERANCE`) covers this.pub fn edge_face_distance(&self, edge: usize, face: usize) -> Result<f64> {+ if on_core() {+ return core::edge_face_distance(self.core()?, edge, face);+ }let (Ok(e), Ok(f)) = (i64::try_from(edge), i64::try_from(face)) else { return Err(error(ffi::ERR_ARG)) };- ffi::measure::edge_face_distance(&self.0, e, f).map_err(error)+ ffi::measure::edge_face_distance(self.cpp()?, e, f).map_err(error)}/// Total area of every face, each counted once, so sheets and open shells too.pub fn area(&self, relative_accuracy: f64) -> Result<f64> {- ffi::measure::area(&self.0, relative_accuracy).map_err(error)+ if on_core() {+ return core::area(self.core()?, relative_accuracy);+ }+ ffi::measure::area(self.cpp()?, relative_accuracy).map_err(error)+ }+}++/// The closed forms of the primitives' measures, for the tests of both kernels.+#[cfg(test)]+pub(crate) mod closed {+ use std::f64::consts::PI;++ /// Area, volume, centroid, Ixx, Iyy, Izz about it (products are 0 for all), and the exact box.+ pub(crate) struct Closed {+ pub area: f64,+ pub volume: f64,+ pub centroid: [f64; 3],+ pub moments: [f64; 3],+ pub bounds: ([f64; 3], [f64; 3]),+ }++ /// An axis-aligned box from its lower corner.+ pub(crate) fn cuboid(o: [f64; 3], size: [f64; 3]) -> Closed {+ let [a, b, c] = size;+ let v = a * b * c;+ Closed {+ area: 2.0 * (a * b + b * c + c * a),+ volume: v,+ centroid: [o[0] + a / 2.0, o[1] + b / 2.0, o[2] + c / 2.0],+ moments: [v * (b * b + c * c) / 12.0, v * (a * a + c * c) / 12.0, v * (a * a + b * b) / 12.0],+ bounds: (o, [o[0] + a, o[1] + b, o[2] + c]),+ }+ }++ /// A cylinder about +Z on its base centre.+ pub(crate) fn cylinder(o: [f64; 3], r: f64, h: f64) -> Closed {+ let v = PI * r * r * h;+ let ixx = v * (3.0 * r * r + h * h) / 12.0;+ Closed {+ area: 2.0 * PI * r * r + 2.0 * PI * r * h,+ volume: v,+ centroid: [o[0], o[1], o[2] + h / 2.0],+ moments: [ixx, ixx, v * r * r / 2.0],+ bounds: ([o[0] - r, o[1] - r, o[2]], [o[0] + r, o[1] + r, o[2] + h]),+ }+ }++ pub(crate) fn sphere(o: [f64; 3], r: f64) -> Closed {+ let v = 4.0 / 3.0 * PI * r * r * r;+ let i = 0.4 * v * r * r;+ Closed {+ area: 4.0 * PI * r * r,+ volume: v,+ centroid: o,+ moments: [i; 3],+ bounds: ([o[0] - r, o[1] - r, o[2] - r], [o[0] + r, o[1] + r, o[2] + r]),+ }+ }++ /// A frustum (a cone when `rt` is 0) about +Z on its base centre. Its volume integrals are+ /// polynomials in z of degree at most 4, so three-point Gauss-Legendre gives them exactly.+ pub(crate) fn cone(o: [f64; 3], rb: f64, rt: f64, h: f64) -> Closed {+ let (x, w) = ([-(0.6f64).sqrt(), 0.0, (0.6f64).sqrt()], [5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0]);+ let (mut v, mut mz, mut zz, mut izz) = (0.0, 0.0, 0.0, 0.0);+ for (xi, wi) in x.iter().zip(w) {+ let (z, wi) = (h / 2.0 * (1.0 + xi), wi * h / 2.0);+ let rho = rb + (rt - rb) * z / h;+ let disc = PI * rho * rho;+ v += wi * disc;+ mz += wi * disc * z;+ zz += wi * disc * z * z;+ izz += wi * disc * rho * rho / 2.0;+ }+ let zc = mz / v;+ let ixx = izz / 2.0 + zz - v * zc * zc;+ let s = ((rb - rt).powi(2) + h * h).sqrt();+ let m = rb.max(rt);+ Closed {+ area: PI * (rb * rb + rt * rt + (rb + rt) * s),+ volume: v,+ centroid: [o[0], o[1], o[2] + zc],+ moments: [ixx, ixx, izz],+ bounds: ([o[0] - m, o[1] - m, o[2]], [o[0] + m, o[1] + m, o[2] + h]),+ }+ }++ /// A ring torus about +Z (Pappus for area and volume).+ pub(crate) fn torus(o: [f64; 3], big: f64, r: f64) -> Closed {+ let v = 2.0 * PI * PI * big * r * r;+ let ixx = v * (big * big / 2.0 + 5.0 * r * r / 8.0);+ let m = big + r;+ Closed {+ area: 4.0 * PI * PI * big * r,+ volume: v,+ centroid: o,+ moments: [ixx, ixx, v * (big * big + 0.75 * r * r)],+ bounds: ([o[0] - m, o[1] - m, o[2] - r], [o[0] + m, o[1] + m, o[2] + r]),+ }}}@@ -96,8 +210,6 @@ impl Brep {mod tests {use super::*;use crate::Error;- use std::f64::consts::PI;-fn rel(a: f64, b: f64) -> f64 {if b == 0.0 { a.abs() } else { (a / b - 1.0).abs() }}@@ -152,7 +264,9 @@ mod tests {v}- /// Closed forms: area, volume, centroid and Ixx, Iyy, Izz about it (products are 0 for all).+ use closed::Closed;++ /// A primitive the C++ kernel made, with its closed forms.struct Expected {name: &'static str,body: Brep,@@ -163,67 +277,24 @@ mod tests {}#[allow(clippy::unwrap_used)] // test fixture+ fn expected(name: &'static str, body: Result<Brep>, c: Closed) -> Expected {+ Expected { name, body: body.unwrap(), area: c.area, volume: c.volume, centroid: c.centroid, moments: c.moments }+ }+fn cylinder(name: &'static str, o: [f64; 3], r: f64, h: f64) -> Expected {- let v = PI * r * r * h;- let ixx = v * (3.0 * r * r + h * h) / 12.0;- Expected {- name,- body: Brep::make_cylinder(o, r, h).unwrap(),- area: 2.0 * PI * r * r + 2.0 * PI * r * h,- volume: v,- centroid: [o[0], o[1], o[2] + h / 2.0],- moments: [ixx, ixx, v * r * r / 2.0],- }+ expected(name, Brep::make_cylinder(o, r, h), closed::cylinder(o, r, h))}- #[allow(clippy::unwrap_used)] // test fixturefn sphere(name: &'static str, o: [f64; 3], r: f64) -> Expected {- let v = 4.0 / 3.0 * PI * r * r * r;- let i = 0.4 * v * r * r;- Expected { name, body: Brep::make_sphere(o, r).unwrap(), area: 4.0 * PI * r * r, volume: v, centroid: o, moments: [i; 3] }+ expected(name, Brep::make_sphere(o, r), closed::sphere(o, r))}- /// A frustum (a cone when `rt` is 0) about +Z on its base centre. Its volume integrals are- /// polynomials in z of degree at most 4, so three-point Gauss-Legendre gives them exactly.- #[allow(clippy::unwrap_used)] // test fixturefn cone(name: &'static str, o: [f64; 3], rb: f64, rt: f64, h: f64) -> Expected {- let (x, w) = ([-(0.6f64).sqrt(), 0.0, (0.6f64).sqrt()], [5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0]);- let (mut v, mut mz, mut zz, mut izz) = (0.0, 0.0, 0.0, 0.0);- for i in 0..3 {- let (z, wi) = (h / 2.0 * (1.0 + x[i]), w[i] * h / 2.0);- let rho = rb + (rt - rb) * z / h;- let disc = PI * rho * rho;- v += wi * disc;- mz += wi * disc * z;- zz += wi * disc * z * z;- izz += wi * disc * rho * rho / 2.0;- }- let zc = mz / v;- let ixx = izz / 2.0 + zz - v * zc * zc;- let s = ((rb - rt).powi(2) + h * h).sqrt();- Expected {- name,- body: Brep::make_cone(o, rb, rt, h).unwrap(),- area: PI * (rb * rb + rt * rt + (rb + rt) * s),- volume: v,- centroid: [o[0], o[1], o[2] + zc],- moments: [ixx, ixx, izz],- }+ expected(name, Brep::make_cone(o, rb, rt, h), closed::cone(o, rb, rt, h))}- /// A ring torus about +Z (Pappus for area and volume).- #[allow(clippy::unwrap_used)] // test fixturefn torus(name: &'static str, o: [f64; 3], big: f64, r: f64) -> Expected {- let v = 2.0 * PI * PI * big * r * r;- let ixx = v * (big * big / 2.0 + 5.0 * r * r / 8.0);- Expected {- name,- body: Brep::make_torus(o, big, r).unwrap(),- area: 4.0 * PI * PI * big * r,- volume: v,- centroid: o,- moments: [ixx, ixx, v * (big * big + 0.75 * r * r)],- }+ expected(name, Brep::make_torus(o, big, r), closed::torus(o, big, r))}/// Every primitive against its closed form, at the origin and 2e5 mm out, to 1e-6 (tests/oraclediff --git a/crates/smlib/src/ops.rs b/crates/smlib/src/ops.rsindex 83f41e12de..f782ee6594 100644--- a/crates/smlib/src/ops.rs+++ b/crates/smlib/src/ops.rs@@ -6,7 +6,7 @@//! edge (face) nearest to it, which must lie within `tolerance` of it and be nearer than any other//! by more than the body's modelling tolerance ([`Error::NoMatch`], [`Error::Ambiguous`]).-use crate::{Brep, Error, Result, error, ffi, init};+use crate::{Brep, Error, Result, core, error, ffi, init, route};/// What size builds a blend SMLib refused ([`blend_fit`]): from the refusal's own cause, never by/// building again.@@ -27,6 +27,11 @@ pub enum Fit {/// ([`Error::NoRoom`]) or whose setback it refused as too short; `None` where it names no single/// size. Read it right after the refused call: SMLib keeps only the last one.pub fn blend_fit() -> Option<Fit> {+ // solidcore names no size that builds yet: its refusals keep their own words, and the C+++ // kernel's last refusal is never read for one of solidcore's.+ if route::backend() == route::Backend::Solidcore {+ return None;+ }let (size, what) = ffi::ops::blend_fit_size()?;match what {ffi::ops::FIT_SIZE => Some(Fit::Size(size)),@@ -76,7 +81,7 @@ pub const MAX_UNION_BREPS: usize = 100_000;/// Most points one selection may hold (the C API's limit).pub const MAX_POINTS: usize = 4096;-fn pick_error((s, at): ffi::ops::PickError) -> Error {+pub(crate) fn pick_error((s, at): ffi::ops::PickError) -> Error {match (s, at) {(ffi::ops::ERR_PICK_NONE, Some(point)) => Error::NoMatch { point },(ffi::ops::ERR_PICK_AMBIGUOUS, Some(point)) => Error::Ambiguous { point },@@ -84,7 +89,7 @@ fn pick_error((s, at): ffi::ops::PickError) -> Error {}}-fn setback_error((s, at, corner): ffi::ops::SetbackError) -> Error {+pub(crate) fn setback_error((s, at, corner): ffi::ops::SetbackError) -> Error {match corner {Some(corner) => Error::CornerRefused { corner },None => pick_error((s, at)),@@ -131,14 +136,17 @@ impl Brep {/// as one body, counted by [`Brep::solid_count`]. Tagged operands ([`Brep::tagged`]) give a/// result whose [`Brep::history`] says where each face and edge came from.pub fn boolean(&self, other: &Brep, op: BooleanOp) -> Result<Option<Brep>> {+ if route::backend() == route::Backend::Solidcore {+ return core::boolean::boolean(self.core()?, other.core()?, op).map(|r| r.map(Brep::made_core));+ }init()?;let op = match op {BooleanOp::Union => ffi::ops::BOOLEAN_UNION,BooleanOp::Subtract => ffi::ops::BOOLEAN_SUBTRACT,BooleanOp::Intersect => ffi::ops::BOOLEAN_INTERSECT,};- match ffi::ops::boolean(&self.0, &other.0, op) {- Ok(h) => Ok(Some(Brep(h))),+ match ffi::ops::boolean(self.cpp()?, other.cpp()?, op) {+ Ok(h) => Ok(Some(Brep::made(h))),Err(ffi::ERR_EMPTY) => Ok(None),Err(s) => Err(error(s)),}@@ -149,26 +157,36 @@ impl Brep {/// tagged each with its own number ([`Brep::tagged`]) give a result whose [`Brep::history`]/// names them. At least one body and at most [`MAX_UNION_BREPS`].pub fn union_all(breps: &[&Brep]) -> Result<Brep> {+ if route::backend() == route::Backend::Solidcore {+ if breps.is_empty() || breps.len() > MAX_UNION_BREPS {+ return Err(Error::Argument);+ }+ let bodies = breps.iter().map(|b| b.core()).collect::<Result<Vec<&core::Body>>>()?;+ return core::boolean::union_all(&bodies).map(Brep::made_core);+ }init()?;if breps.is_empty() || breps.len() > MAX_UNION_BREPS {return Err(error(ffi::ERR_ARG));}- let handles: Vec<&ffi::Handle> = breps.iter().map(|b| &b.0).collect();- ffi::ops::boolean_union_all(&handles).map(Brep).map_err(error)+ let handles = breps.iter().map(|b| b.cpp()).collect::<Result<Vec<&ffi::Handle>>>()?;+ ffi::ops::boolean_union_all(&handles).map(Brep::made).map_err(error)}/// `self` and `other`, sheets of planar faces on one plane ([`Brep::planar_faces`]), combined/// as regions of that plane by `op`: `None` when the result is empty. The result's edges are/// the inputs' own curves, split where they cross.pub fn boolean2d(&self, other: &Brep, op: BooleanOp) -> Result<Option<Brep>> {+ if route::backend() == route::Backend::Solidcore {+ return core::boolean::boolean2d(self.core()?, other.core()?, op).map(|r| r.map(Brep::made_core));+ }init()?;let op = match op {BooleanOp::Union => ffi::ops::BOOLEAN_UNION,BooleanOp::Subtract => ffi::ops::BOOLEAN_SUBTRACT,BooleanOp::Intersect => ffi::ops::BOOLEAN_INTERSECT,};- match ffi::ops::boolean2d(&self.0, &other.0, op) {- Ok(h) => Ok(Some(Brep(h))),+ match ffi::ops::boolean2d(self.cpp()?, other.cpp()?, op) {+ Ok(h) => Ok(Some(Brep::made(h))),Err(ffi::ERR_EMPTY) => Ok(None),Err(s) => Err(error(s)),}@@ -178,9 +196,12 @@ impl Brep {/// one body: `None` when the tool meets no face. Tagged operands give the pieces' history/// (each piece is a split of the face it was cut from).pub fn imprint(&self, tool: &Brep) -> Result<Option<Brep>> {+ if route::backend() == route::Backend::Solidcore {+ return core::boolean::imprint(self.core()?, tool.core()?).map(|r| r.map(Brep::made_core));+ }init()?;- match ffi::ops::imprint(&self.0, &tool.0) {- Ok(h) => Ok(Some(Brep(h))),+ match ffi::ops::imprint(self.cpp()?, tool.cpp()?) {+ Ok(h) => Ok(Some(Brep::made(h))),Err(ffi::ops::ERR_NO_CUT) => Ok(None),Err(s) => Err(error(s)),}@@ -188,12 +209,18 @@ impl Brep {/// The number of separate solid regions (voids not counted).pub fn solid_count(&self) -> Result<usize> {- ffi::ops::solid_count(&self.0).map(|n| usize::try_from(n).unwrap_or(0)).map_err(error)+ if route::backend() == route::Backend::Solidcore {+ return crate::core::solid_count(self.core()?);+ }+ ffi::ops::solid_count(self.cpp()?).map(|n| usize::try_from(n).unwrap_or(0)).map_err(error)}/// The edges nearest to `edges` (each within `tolerance`), exactly those, rounded/// at `radius`.pub fn fillet(&self, edges: &[[f64; 3]], tolerance: f64, radius: f64) -> Result<Brep> {+ if route::backend() == route::Backend::Solidcore {+ return self.core_blend(Blend::Round, edges, &[radius], tolerance, &[], &[], core::blend::Corners::Filled);+ }self.pick_op(ffi::ops::Pick::Fillet, edges, tolerance, radius, false)}@@ -201,40 +228,49 @@ impl Brep {/// an equal-distance chamfer `distance` back along each face (measured at each edge's/// midpoint), with bevelled corners.pub fn chamfer(&self, edges: &[[f64; 3]], tolerance: f64, distance: f64) -> Result<Brep> {+ if route::backend() == route::Backend::Solidcore {+ return self.core_blend(Blend::Chamfer, edges, &[distance], tolerance, &[], &[], core::blend::Corners::Filled);+ }self.pick_op(ffi::ops::Pick::Chamfer, edges, tolerance, distance, false)}/// The edges nearest to `edges` (each within `tolerance`), exactly those, blended/// as `kind`, edge i at `sizes[i]`.pub fn blend(&self, kind: Blend, edges: &[[f64; 3]], sizes: &[f64], tolerance: f64) -> Result<Brep> {- init()?;if edges.len() > MAX_POINTS || edges.is_empty() || sizes.len() != edges.len() {return Err(Error::Argument);}+ if route::backend() == route::Backend::Solidcore {+ return self.core_blend(kind, edges, sizes, tolerance, &[], &[], core::blend::Corners::Filled);+ }+ init()?;let kind = match kind {Blend::Round => ffi::ops::BLEND_ROUND,Blend::Curvature => ffi::ops::BLEND_CURVATURE,Blend::Chord => ffi::ops::BLEND_CHORD,Blend::Chamfer => ffi::ops::BLEND_CHAMFER,};- ffi::ops::blend(kind, &self.0, edges, sizes, tolerance).map(Brep).map_err(pick_error)+ ffi::ops::blend(kind, self.cpp()?, edges, sizes, tolerance).map(Brep::made).map_err(pick_error)}/// [`Brep::blend`], with whether each point picked an edge that a larger round, overflowing/// its faces, removed whole: that edge is gone and not rounded (SMLib rounds the edges whose/// blends overflow first, then what is left of the others).pub fn blend_dropping(&self, kind: Blend, edges: &[[f64; 3]], sizes: &[f64], tolerance: f64) -> Result<(Brep, Vec<bool>)> {- init()?;if edges.len() > MAX_POINTS || edges.is_empty() || sizes.len() != edges.len() {return Err(Error::Argument);}+ if route::backend() == route::Backend::Solidcore {+ return core::blend::blend_dropping(self.core()?, kind, edges, sizes, tolerance).map(|(b, d)| (Brep::made_core(b), d));+ }+ init()?;let kind = match kind {Blend::Round => ffi::ops::BLEND_ROUND,Blend::Curvature => ffi::ops::BLEND_CURVATURE,Blend::Chord => ffi::ops::BLEND_CHORD,Blend::Chamfer => ffi::ops::BLEND_CHAMFER,};- ffi::ops::blend_dropping(kind, &self.0, edges, sizes, tolerance).map(|(b, d)| (Brep(b), d)).map_err(pick_error)+ ffi::ops::blend_dropping(kind, self.cpp()?, edges, sizes, tolerance).map(|(b, d)| (Brep::made(b), d)).map_err(pick_error)}/// [`Brep::blend`] with corner setbacks: each of `corners` picks the vertex nearest it@@ -251,7 +287,6 @@ impl Brep {setbacks: &[f64],tolerance: f64,) -> Result<Brep> {- init()?;if edges.len() > MAX_POINTS|| edges.is_empty()|| sizes.len() != edges.len()@@ -261,13 +296,17 @@ impl Brep {{return Err(Error::Argument);}+ if route::backend() == route::Backend::Solidcore {+ return self.core_blend(kind, edges, sizes, tolerance, corners, setbacks, core::blend::Corners::Filled);+ }+ init()?;let kind = match kind {Blend::Round => ffi::ops::BLEND_ROUND,Blend::Curvature => ffi::ops::BLEND_CURVATURE,Blend::Chord => ffi::ops::BLEND_CHORD,Blend::Chamfer => ffi::ops::BLEND_CHAMFER,};- ffi::ops::blend_setback(kind, &self.0, edges, sizes, corners, setbacks, tolerance).map(Brep).map_err(setback_error)+ ffi::ops::blend_setback(kind, self.cpp()?, edges, sizes, corners, setbacks, tolerance).map(Brep::made).map_err(setback_error)}/// [`Brep::blend_setback`] with each set-back corner left open: SMLib's patch between the@@ -284,7 +323,6 @@ impl Brep {setbacks: &[f64],tolerance: f64,) -> Result<(Brep, Vec<Hole>)> {- init()?;if edges.len() > MAX_POINTS|| edges.is_empty()|| sizes.len() != edges.len()@@ -294,16 +332,21 @@ impl Brep {{return Err(Error::Argument);}+ if route::backend() == route::Backend::Solidcore {+ return core::blend::blend_holes(self.core()?, kind, edges, sizes, tolerance, corners, setbacks, core::blend::Corners::Open)+ .map(|(b, holes)| (Brep::made_core(b), holes));+ }+ init()?;let kind = match kind {Blend::Round => ffi::ops::BLEND_ROUND,Blend::Curvature => ffi::ops::BLEND_CURVATURE,Blend::Chord => ffi::ops::BLEND_CHORD,Blend::Chamfer => ffi::ops::BLEND_CHAMFER,};- let (h, values) = ffi::ops::blend_setback_open(kind, &self.0, edges, sizes, corners, setbacks, tolerance).map_err(setback_error)?;+ let (h, values) = ffi::ops::blend_setback_open(kind, self.cpp()?, edges, sizes, corners, setbacks, tolerance).map_err(setback_error)?;// A buffer that does not read as the C API documents it is a buffer error.let holes = holes(&values, corners.len()).ok_or_else(|| error(ffi::ERR_BUFFER))?;- Ok((Brep(h), holes))+ Ok((Brep::made(h), holes))}/// The one edge nearest to `edge` (within `tolerance`) rounded with a radius@@ -311,9 +354,12 @@ impl Brep {/// `radii` over the position along the edge, 0 at its end nearest `start` and 1 at the other/// (the edge curve's parameter scaled to 0..1).pub fn fillet_variable(&self, edge: [f64; 3], tolerance: f64, start: [f64; 3], degree: usize, knots: &[f64], radii: &[f64]) -> Result<Brep> {+ if route::backend() == route::Backend::Solidcore {+ return core::blend::fillet_variable(self.core()?, edge, tolerance, start, degree, knots, radii).map(Brep::made_core);+ }init()?;let degree = i32::try_from(degree).map_err(|_| Error::Argument)?;- ffi::ops::fillet_variable(&self.0, &edge, tolerance, &start, degree, knots, radii).map(Brep).map_err(|s| match s {+ ffi::ops::fillet_variable(self.cpp()?, &edge, tolerance, &start, degree, knots, radii).map(Brep::made).map_err(|s| match s {ffi::ops::ERR_PICK_NONE => Error::NoMatch { point: 0 },ffi::ops::ERR_PICK_AMBIGUOUS => Error::Ambiguous { point: 0 },s => error(s),@@ -325,15 +371,18 @@ impl Brep {/// and by `second` on the other, with bevelled corners (setbacks measured at each edge's/// midpoint).pub fn chamfer_sides(&self, edges: &[[f64; 3]], tolerance: f64, distance: f64, second: ChamferSecond, first: [f64; 3]) -> Result<Brep> {- init()?;if edges.is_empty() || edges.len() > MAX_POINTS {return Err(Error::Argument);}+ if route::backend() == route::Backend::Solidcore {+ return core::blend::chamfer_sides(self.core()?, edges, tolerance, distance, second, first).map(Brep::made_core);+ }+ init()?;let (value, angle) = match second {ChamferSecond::Distance(d) => (d, false),ChamferSecond::Angle(a) => (a, true),};- ffi::ops::chamfer_sides(&self.0, edges, tolerance, distance, value, angle, &first).map(Brep).map_err(pick_error)+ ffi::ops::chamfer_sides(self.cpp()?, edges, tolerance, distance, value, angle, &first).map(Brep::made).map_err(pick_error)}/// Hollowed to a wall of `thickness` (negative: inside the original surface, positive:@@ -342,6 +391,9 @@ impl Brep {/// whose walls would just meet (a hole exactly twice the wall from a side) is/// [`Error::WallsTouch`].pub fn shell(&self, open_faces: &[[f64; 3]], tolerance: f64, thickness: f64) -> Result<Brep> {+ if route::backend() == route::Backend::Solidcore {+ return core::offset::shell(self.core()?, open_faces, tolerance, thickness).map(Brep::made_core);+ }self.pick_op(ffi::ops::Pick::Shell, open_faces, tolerance, thickness, true)}@@ -350,6 +402,9 @@ impl Brep {/// faces around them extended or trimmed to meet them. Faces moved in past all of the body/// behind them are [`Error::NoRoom`].pub fn offset_faces(&self, faces: &[[f64; 3]], tolerance: f64, distance: f64) -> Result<Brep> {+ if route::backend() == route::Backend::Solidcore {+ return core::offset::offset_faces(self.core()?, faces, tolerance, distance).map(Brep::made_core);+ }self.pick_op(ffi::ops::Pick::OffsetFaces, faces, tolerance, distance, false)}@@ -357,8 +412,11 @@ impl Brep {/// against them), or by half each way when `symmetric`, with ruled walls along its open/// edges. A closed solid is [`Error::Argument`].pub fn thicken(&self, thickness: f64, symmetric: bool) -> Result<Brep> {+ if route::backend() == route::Backend::Solidcore {+ return core::offset::thicken(self.core()?, thickness, symmetric).map(Brep::made_core);+ }init()?;- ffi::ops::thicken(&self.0, thickness, symmetric).map(Brep).map_err(error)+ ffi::ops::thicken(self.cpp()?, thickness, symmetric).map(Brep::made).map_err(error)}/// This body with its topological edges and vertices removed (SMLib's@@ -367,11 +425,14 @@ impl Brep {/// The edges nearest to `keep` (each within `tolerance`) stay. The shape is unchanged, and/// SMLib's history tags follow the merge.pub fn merge_faces(&self, keep: &[[f64; 3]], tolerance: f64) -> Result<Brep> {- init()?;if keep.len() > MAX_POINTS {return Err(Error::Argument);}- ffi::ops::merge_faces(&self.0, keep, tolerance).map(Brep).map_err(pick_error)+ if route::backend() == route::Backend::Solidcore {+ return core::merge::merge_faces(self.core()?, keep, tolerance).map(Brep::made_core);+ }+ init()?;+ ffi::ops::merge_faces(self.cpp()?, keep, tolerance).map(Brep::made).map_err(pick_error)}/// The flat faces nearest to `faces` (each within `tolerance`) tilted by `angle` radians@@ -388,11 +449,32 @@ impl Brep {pull: [f64; 3],angle: f64,) -> Result<Brep> {- init()?;if faces.is_empty() || faces.len() > MAX_POINTS {return Err(Error::Argument);}- ffi::ops::draft(&self.0, faces, tolerance, &neutral_origin, &neutral_normal, &pull, angle).map(Brep).map_err(pick_error)+ if route::backend() == route::Backend::Solidcore {+ return core::offset::draft(self.core()?, faces, tolerance, neutral_origin, neutral_normal, pull, angle).map(Brep::made_core);+ }+ init()?;+ ffi::ops::draft(self.cpp()?, faces, tolerance, &neutral_origin, &neutral_normal, &pull, angle).map(Brep::made).map_err(pick_error)+ }++ /// [`Brep::blend`] and its kin on solidcore (`core::blend::blend`).+ #[allow(clippy::too_many_arguments)]+ fn core_blend(+ &self,+ kind: Blend,+ edges: &[[f64; 3]],+ sizes: &[f64],+ tolerance: f64,+ corners: &[[f64; 3]],+ setbacks: &[f64],+ open: core::blend::Corners,+ ) -> Result<Brep> {+ if edges.len() > MAX_POINTS || edges.is_empty() {+ return Err(Error::Argument);+ }+ core::blend::blend(self.core()?, kind, edges, sizes, tolerance, corners, setbacks, open).map(Brep::made_core)}fn pick_op(&self, kind: ffi::ops::Pick, points: &[[f64; 3]], tolerance: f64, size: f64, allow_none: bool) -> Result<Brep> {@@ -400,7 +482,7 @@ impl Brep {if points.len() > MAX_POINTS || (points.is_empty() && !allow_none) {return Err(Error::Argument);}- ffi::ops::pick_op(kind, &self.0, points, tolerance, size).map(Brep).map_err(pick_error)+ ffi::ops::pick_op(kind, self.cpp()?, points, tolerance, size).map(Brep::made).map_err(pick_error)}}diff --git a/crates/smlib/src/ops_tests.rs b/crates/smlib/src/ops_tests.rsindex 0260ac40e2..785b4f9b73 100644--- a/crates/smlib/src/ops_tests.rs+++ b/crates/smlib/src/ops_tests.rs@@ -402,7 +402,8 @@ fn a_setback_corner_left_open_returns_its_hole() {let (open, holes) = b.blend_setback_open(Blend::Round, &edges, &[5.0; 3], &[[60.0, 40.0, 20.0]], &[8.0], 0.1).unwrap();// The call is a profiler span like every other, timed by the C API.let report = mark.report();- assert!(report.rows.iter().any(|r| r.category == "smlib" && r.name == "smlib_blend_setback_open"), "{report:?}");+ let on_cpp = crate::route::backend() == crate::route::Backend::Smlib;+ assert!(!on_cpp || report.rows.iter().any(|r| r.category == "smlib" && r.name == "smlib_blend_setback_open"), "{report:?}");shot(&open, "setback_open");assert_eq!(open.counts().unwrap(), [9, 30, 22]);assert!(!open.is_manifold_solid().unwrap());diff --git a/crates/smlib/src/pcurves.rs b/crates/smlib/src/pcurves.rsindex 3fd64a8f75..19554749d5 100644--- a/crates/smlib/src/pcurves.rs+++ b/crates/smlib/src/pcurves.rs@@ -22,7 +22,7 @@ impl Trims for SmlibTrims {fn trims(face: &TrimFace<'_>) -> Result<Vec<Vec<Curve2>>, String> {let (record, bare) = sheet(face)?;let mut arrays = crate::import::arrays_with_bare_uses(&record, &bare).map_err(|e| e.to_string())?;- let import = |a: &crate::import::Arrays| crate::flat::Flat::from_arrays(a).and_then(|f| f.import()).map_err(|e| e.to_string());+ let import = |a: &crate::import::Arrays| crate::Brep::from_arrays(a).map_err(|e| e.to_string());let mut body = import(&arrays)?;if cover_gaps(&body, face, &bare, &mut arrays)? {body = import(&arrays)?;diff --git a/crates/smlib/src/route.rs b/crates/smlib/src/route.rsnew file mode 100644index 0000000000..60cff4d62e--- /dev/null+++ b/crates/smlib/src/route.rs@@ -0,0 +1,171 @@+//! Which kernel this process runs on: solidcore, the Rust port of SMLib, unless the C++ SMLib+//! fork is asked for. One kernel answers every operation.+//!+//! The C++ kernel is an opt-in: for a test, a rig or a user who wants the old behaviour. A call that+//! fails on solidcore fails, and a path solidcore has no answer for says it is not supported: there is+//! no fallback to the other kernel at run time, which would hide its bugs. Asking for the C++ kernel on+//! a build without it (the default, wasm included) stays on it too: every call answers+//! [`crate::Error::NotBuilt`], which says to build with `--features smlib`.+//!+//! `SOLIDCRAFT_KERNEL=smlib|solidcore` chooses for the whole process (the rig, the test matrix);+//! otherwise the preference ([`set_choice`]) does, and it defaults to solidcore.++use std::sync::OnceLock;+use std::sync::atomic::{AtomicBool, Ordering};++/// A kernel the process runs on.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum Backend {+ /// The C++ SMLib fork (tangency-labs/smlib) behind its C API.+ Smlib,+ /// solidcore (tangency-labs/solidcore), the Rust port of SMLib.+ Solidcore,+}++impl Backend {+ /// The id `SOLIDCRAFT_KERNEL`, preferences and reports spell it with.+ pub fn id(self) -> &'static str {+ match self {+ Backend::Smlib => "smlib",+ Backend::Solidcore => "solidcore",+ }+ }++ /// Back from an id; anything else is `None`.+ pub fn from_id(id: &str) -> Option<Backend> {+ [Backend::Smlib, Backend::Solidcore].into_iter().find(|b| b.id() == id)+ }+}++#[cfg(test)]+thread_local! {+ /// Tests: this thread's operations run on the C++ kernel whatever the choice.+ static ON_CPP: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };+ /// Tests: how many times this thread has touched a C++ body, and called solidcore.+ static REACHED: std::cell::Cell<(u64, u64)> = const { std::cell::Cell::new((0, 0)) };+}++/// Tests: this thread has touched a C++ body.+#[cfg(test)]+pub(crate) fn reached_cpp() {+ REACHED.with(|r| r.set((r.get().0 + 1, r.get().1)));+}++/// Tests: this thread has called solidcore.+#[cfg(test)]+pub(crate) fn reached_core() {+ REACHED.with(|r| r.set((r.get().0, r.get().1 + 1)));+}++/// Tests: how many times this thread has touched a C++ body and called solidcore since the last+/// time this was asked.+#[cfg(test)]+pub(crate) fn take_reached() -> (u64, u64) {+ REACHED.with(|r| r.replace((0, 0)))+}++/// Tests that exercise the C++ kernel opt in: until the guard drops, this thread's operations run+/// on it. Thread by thread, so that the other tests in the binary stay on the process's kernel. The+/// guard fails a test that never touched a C++ body, so a parity test can't quietly compare+/// solidcore with itself.+#[cfg(test)]+#[cfg_attr(not(feature = "native"), allow(dead_code))]+pub(crate) fn on_cpp() -> impl Drop {+ struct Guard;+ impl Drop for Guard {+ fn drop(&mut self) {+ ON_CPP.with(|c| c.set(false));+ let (cpp, core) = REACHED.with(std::cell::Cell::get);+ if std::env::var_os("SOLIDCRAFT_TEST_REACHED").is_some() {+ eprintln!("REACHED {} cpp={cpp} core={core}", std::thread::current().name().unwrap_or("?"));+ }+ assert!(cpp > 0 || std::thread::panicking(), "this test opted in to the C++ kernel and never reached it");+ }+ }+ ON_CPP.with(|c| c.set(true));+ REACHED.with(|r| r.set((0, 0)));+ Guard+}++/// The kernel that answers now: `SOLIDCRAFT_KERNEL`, else the preference, else solidcore.+pub fn backend() -> Backend {+ #[cfg(test)]+ if ON_CPP.with(std::cell::Cell::get) {+ return Backend::Smlib;+ }+ choice()+}++/// `SOLIDCRAFT_KERNEL`, read once. An unknown value is no override (and says so in the log).+fn environment() -> Option<Backend> {+ static ENV: OnceLock<Option<Backend>> = OnceLock::new();+ *ENV.get_or_init(|| {+ let v = std::env::var("SOLIDCRAFT_KERNEL").ok()?;+ let c = Backend::from_id(&v);+ if c.is_none() {+ log::warn!(target: "smlib", "SOLIDCRAFT_KERNEL={v}: not smlib or solidcore; ignored");+ }+ if c == Some(Backend::Smlib) && !crate::built() {+ log::warn!(target: "smlib", "SOLIDCRAFT_KERNEL=smlib: {}; every operation will be refused", crate::NOT_BUILT);+ }+ c+ })+}++/// The preference: false for solidcore, true for the C++ kernel.+static PREFERS_CPP: AtomicBool = AtomicBool::new(false);++/// The choice in force: `SOLIDCRAFT_KERNEL` when it is set, else the preference.+pub fn choice() -> Backend {+ environment().unwrap_or_else(|| if PREFERS_CPP.load(Ordering::Relaxed) { Backend::Smlib } else { Backend::Solidcore })+}++/// Sets the preference. `SOLIDCRAFT_KERNEL`, when set, still wins.+pub fn set_choice(b: Backend) {+ PREFERS_CPP.store(b == Backend::Smlib, Ordering::Relaxed);+}++/// Whether `SOLIDCRAFT_KERNEL` overrides the preference in this process.+pub fn overridden() -> bool {+ environment().is_some()+}++#[cfg(test)]+mod tests {+ use super::*;++ /// The two ids round trip; `routed`, the old default, is not one of them.+ #[test]+ fn ids_round_trip() {+ for b in [Backend::Smlib, Backend::Solidcore] {+ assert_eq!(Backend::from_id(b.id()), Some(b));+ }+ for other in ["routed", "truck", "SMLIB", ""] {+ assert_eq!(Backend::from_id(other), None, "{other}");+ }+ }++ /// With nothing chosen the process is on solidcore. (Only solidcore is set here: the other tests+ /// in this binary build bodies meanwhile.)+ #[test]+ fn the_default_is_solidcore() {+ if overridden() {+ return;+ }+ set_choice(Backend::Solidcore);+ assert_eq!((choice(), backend()), (Backend::Solidcore, Backend::Solidcore));+ }++ /// The guard moves this thread alone onto the C++ kernel, and back when it drops.+ #[test]+ fn a_test_opts_in_to_the_cpp_kernel_thread_by_thread() {+ let before = backend();+ {+ let _cpp = on_cpp();+ reached_cpp();+ assert_eq!(backend(), Backend::Smlib);+ assert_eq!(choice(), before);+ }+ assert_eq!(backend(), before);+ }+}diff --git a/crates/smlib/src/sheets.rs b/crates/smlib/src/sheets.rsindex f05306f440..b2540bdb4f 100644--- a/crates/smlib/src/sheets.rs+++ b/crates/smlib/src/sheets.rs@@ -3,21 +3,27 @@//! tagged inputs ([`Brep::tagged`]) give results whose [`Brep::history`] says where each face and//! edge came from.-use crate::{Brep, Result, error, ffi, init};+use crate::{Brep, Result, core, error, ffi, init, route};impl Brep {/// The faces sewn along the vertices and edges that coincide within `tolerance` mm, oriented/// outward where they close into a solid, else only made to agree across their shared edges;/// with whether the result is a closed solid.pub fn stitch(&self, tolerance: f64) -> Result<(Brep, bool)> {+ if route::backend() == route::Backend::Solidcore {+ return core::merge::stitch(self.core()?, tolerance).map(|(b, closed)| (Brep::made_core(b), closed));+ }init()?;- ffi::sheets::stitch(&self.0, tolerance).map(|(h, closed)| (Brep(h), closed)).map_err(error)+ ffi::sheets::stitch(self.cpp()?, tolerance).map(|(h, closed)| (Brep::made(h), closed)).map_err(error)}/// This sheet with every face moved onto its surface's offset by `distance` along its normal/// (negative: against it). A closed solid is [`crate::Error::Argument`].pub fn offset_sheet(&self, distance: f64) -> Result<Brep> {+ if route::backend() == route::Backend::Solidcore {+ return core::offset::offset_sheet(self.core()?, distance).map(Brep::made_core);+ }init()?;- ffi::sheets::offset_sheet(&self.0, distance).map(Brep).map_err(error)+ ffi::sheets::offset_sheet(self.cpp()?, distance).map(Brep::made).map_err(error)}}diff --git a/crates/smlib/src/split.rs b/crates/smlib/src/split.rsindex 0ca7b02991..a3dbba8766 100644--- a/crates/smlib/src/split.rs+++ b/crates/smlib/src/split.rs@@ -3,7 +3,7 @@//! taken over its whole domain.use crate::ssi::Surface;-use crate::{Brep, Error, Result, error, ffi, init};+use crate::{Brep, Error, Result, core, error, ffi, init, route};impl Brep {/// `self` with faces `faces` (indices in SMLib's face order, distinct) cut where each of@@ -11,14 +11,18 @@ impl Brep {/// for each face how many faces it became besides itself (0: no tool split it). `None` when/// no face is split. Tagged operands ([`Brep::tagged`]) give the pieces' history.pub fn split_faces(&self, faces: &[usize], tools: &[&Surface]) -> Result<Option<(Brep, Vec<usize>)>> {- init()?;if faces.is_empty() || faces.len() > ffi::split::MAX_FACES || tools.is_empty() || tools.len() > ffi::split::MAX_TOOLS {return Err(Error::Argument);}+ if route::backend() == route::Backend::Solidcore {+ let specs: Vec<&crate::ssi::Spec> = tools.iter().map(|t| t.spec()).collect();+ return core::split::split_faces(self.core()?, faces, &specs).map(|r| r.map(|(b, made)| (Brep::made_core(b), made)));+ }+ init()?;let faces: Vec<i64> = faces.iter().map(|f| i64::try_from(*f).map_err(|_| Error::Argument)).collect::<Result<_>>()?;- let handles: Vec<&ffi::ssi::SurfaceHandle> = tools.iter().map(|t| t.handle()).collect();- match ffi::split::split_faces(&self.0, &faces, &handles) {- Ok((h, made)) => Ok(Some((Brep(h), made.into_iter().map(|m| usize::try_from(m).unwrap_or(0)).collect()))),+ let handles: Vec<&ffi::ssi::SurfaceHandle> = tools.iter().map(|t| t.handle()).collect::<Result<_>>()?;+ match ffi::split::split_faces(self.cpp()?, &faces, &handles) {+ Ok((h, made)) => Ok(Some((Brep::made(h), made.into_iter().map(|m| usize::try_from(m).unwrap_or(0)).collect()))),Err(ffi::ops::ERR_NO_CUT) => Ok(None),Err(s) => Err(error(s)),}@@ -30,9 +34,12 @@ impl Brep {/// leaves both parts the whole body, with no face from the tool (tag `self` to tell); `None`/// when a side is left empty.pub fn split_body(&self, tool: &Surface) -> Result<Option<(Brep, Brep)>> {+ if route::backend() == route::Backend::Solidcore {+ return core::split::split_body(self.core()?, tool.spec()).map(|r| r.map(|(b, f)| (Brep::made_core(b), Brep::made_core(f))));+ }init()?;- match ffi::split::split_body(&self.0, tool.handle()) {- Ok((b, f)) => Ok(Some((Brep(b), Brep(f)))),+ match ffi::split::split_body(self.cpp()?, tool.handle()?) {+ Ok((b, f)) => Ok(Some((Brep::made(b), Brep::made(f)))),Err(ffi::ops::ERR_NO_CUT) => Ok(None),Err(s) => Err(error(s)),}@@ -44,10 +51,14 @@ impl Brep {/// normal and the part in front. A `sheet` that is no sheet, or a `face` it does not have, is/// [`Error::Argument`].pub fn split_body_by_sheet(&self, sheet: &Brep, face: usize) -> Result<Option<(Brep, Brep)>> {+ if route::backend() == route::Backend::Solidcore {+ return core::split::split_body_by_sheet(self.core()?, sheet.core()?, face)+ .map(|r| r.map(|(b, f)| (Brep::made_core(b), Brep::made_core(f))));+ }init()?;let face = i64::try_from(face).map_err(|_| Error::Argument)?;- match ffi::split::split_body_by_sheet(&self.0, &sheet.0, face) {- Ok((b, f)) => Ok(Some((Brep(b), Brep(f)))),+ match ffi::split::split_body_by_sheet(self.cpp()?, sheet.cpp()?, face) {+ Ok((b, f)) => Ok(Some((Brep::made(b), Brep::made(f)))),Err(ffi::ops::ERR_NO_CUT) => Ok(None),Err(s) => Err(error(s)),}diff --git a/crates/smlib/src/ssi.rs b/crates/smlib/src/ssi.rsindex 96fae8477a..040a244e38 100644--- a/crates/smlib/src/ssi.rs+++ b/crates/smlib/src/ssi.rs@@ -8,10 +8,30 @@use solidcraft_geom::brep as b;-use crate::{Error, Result, error, ffi, init};+use std::sync::OnceLock;-/// A surface with its UV domain, owned on the C side.-pub struct Surface(ffi::ssi::SurfaceHandle);+use crate::{Error, Result, error, ffi, init, route};++/// A surface with its UV domain: the description it was made from, from which solidcore makes its+/// own ([`crate::core::split`]), and the C side's, made when the C++ kernel needs it.+pub struct Surface {+ handle: OnceLock<Result<ffi::ssi::SurfaceHandle>>,+ /// solidcore's, made when it is first needed.+ core: OnceLock<Result<crate::core::split::Tool>>,+ spec: Spec,+}++/// What a [`Surface`] was made from: its constructor's arguments, checked as the C API checks them+/// ([`Spec::check`]).+#[derive(Clone, Debug, PartialEq)]+pub(crate) enum Spec {+ Plane { origin: [f64; 3], xaxis: [f64; 3], yaxis: [f64; 3], u: [f64; 2], v: [f64; 2] },+ Cylinder { origin: [f64; 3], xaxis: [f64; 3], yaxis: [f64; 3], radius: f64, angle_deg: [f64; 2], height: [f64; 2] },+ Cone { apex: [f64; 3], xaxis: [f64; 3], yaxis: [f64; 3], half_angle_deg: f64, height: [f64; 2] },+ Sphere { center: [f64; 3], xaxis: [f64; 3], yaxis: [f64; 3], radius: f64, lon_deg: [f64; 2], lat_deg: [f64; 2] },+ Torus { center: [f64; 3], xaxis: [f64; 3], yaxis: [f64; 3], major_radius: f64, minor_radius: f64, major_deg: [f64; 2], minor_deg: [f64; 2] },+ Nurbs { degree: [usize; 2], nu: usize, nv: usize, knots_u: Vec<f64>, knots_v: Vec<f64>, points: Vec<[f64; 3]>, weights: Option<Vec<f64>> },+}impl std::fmt::Debug for Surface {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {@@ -23,35 +43,166 @@ fn int(n: usize) -> Result<i32> {i32::try_from(n).map_err(|_| Error::Argument)}+/// The largest coordinate, degree and control net the C API takes (`SMLIB_SURFACE_MAX_*`).+const MAX_COORD: f64 = 1e8;+const MAX_DEGREE: usize = 25;+const MAX_POLES: usize = 1_000_000;++fn bounded(v: &[f64]) -> bool {+ v.iter().all(|x| x.is_finite() && x.abs() <= MAX_COORD)+}++/// Two non-zero axes that are not (nearly) parallel.+fn axes(x: &[f64; 3], y: &[f64; 3]) -> bool {+ let len = |a: &[f64; 3]| (a[0] * a[0] + a[1] * a[1] + a[2] * a[2]).sqrt();+ let c = [x[1] * y[2] - x[2] * y[1], x[2] * y[0] - x[0] * y[2], x[0] * y[1] - x[1] * y[0]];+ bounded(x) && bounded(y) && len(x) > 1e-12 && len(y) > 1e-12 && len(&c) > 1e-9 * len(x) * len(y)+}++/// An increasing interval inside `[lo, hi]` spanning at most `span`.+fn range(r: &[f64; 2], lo: f64, hi: f64, span: f64) -> bool {+ bounded(r) && r[0] < r[1] && r[0] >= lo && r[1] <= hi && r[1] - r[0] <= span+}++fn length(x: f64) -> bool {+ x.is_finite() && x > 1e-9 && x <= MAX_COORD+}++/// A knot vector of n + p + 1 non-decreasing values with a non-empty domain `[k[p], k[n]]`, no+/// interior knot repeated more than p times and no end knot more than p + 1.+fn knots(k: &[f64], n: usize, p: usize) -> bool {+ if k.len() != n + p + 1 || !bounded(k) || k.windows(2).any(|w| w[1] < w[0]) {+ return false;+ }+ let (Some(lo), Some(hi)) = (k.get(p).copied(), k.get(n).copied()) else { return false };+ let mut run = 1;+ for w in k.windows(2) {+ run = if w[1] == w[0] { run + 1 } else { 1 };+ if run > p + 1 || (run > p && w[1] > lo && w[1] < hi) {+ return false;+ }+ }+ lo < hi+}++impl Spec {+ /// The checks each of the C API's constructors makes of its arguments, so that a surface is+ /// refused alike on either kernel, and without the C++ kernel.+ fn check(&self) -> Result<()> {+ let whole = |r: &[f64; 2]| range(r, -MAX_COORD, MAX_COORD, 2.0 * MAX_COORD);+ let turn = |r: &[f64; 2]| range(r, -360.0, 360.0, 360.0);+ let ok = match self {+ Spec::Plane { origin, xaxis, yaxis, u, v } => bounded(origin) && axes(xaxis, yaxis) && whole(u) && whole(v),+ Spec::Cylinder { origin, xaxis, yaxis, radius, angle_deg, height } => {+ bounded(origin) && axes(xaxis, yaxis) && length(*radius) && turn(angle_deg) && range(height, -MAX_COORD, MAX_COORD, MAX_COORD)+ }+ Spec::Cone { apex, xaxis, yaxis, half_angle_deg, height } => {+ bounded(apex)+ && axes(xaxis, yaxis)+ && (0.01..=89.0).contains(half_angle_deg)+ && range(height, 0.0, MAX_COORD, MAX_COORD)+ && height[1] - height[0] > 1e-9+ }+ Spec::Sphere { center, xaxis, yaxis, radius, lon_deg, lat_deg } => {+ bounded(center) && axes(xaxis, yaxis) && length(*radius) && turn(lon_deg) && range(lat_deg, -90.0, 90.0, 180.0)+ }+ Spec::Torus { center, xaxis, yaxis, major_radius, minor_radius, major_deg, minor_deg } => {+ bounded(center)+ && axes(xaxis, yaxis)+ && length(*major_radius)+ && length(*minor_radius)+ && minor_radius < major_radius+ && turn(major_deg)+ && turn(minor_deg)+ }+ Spec::Nurbs { degree: [p, q], nu, nv, knots_u, knots_v, points, weights } => {+ (1..=MAX_DEGREE).contains(p)+ && (1..=MAX_DEGREE).contains(q)+ && *nu > *p+ && *nv > *q+ && nu.checked_mul(*nv).is_some_and(|n| n <= MAX_POLES && points.len() == n)+ && knots(knots_u, *nu, *p)+ && knots(knots_v, *nv, *q)+ && points.iter().all(|c| bounded(c))+ && weights.as_ref().is_none_or(|w| w.len() == points.len() && w.iter().all(|x| (1e-6..=1e6).contains(x)))+ }+ };+ if ok { Ok(()) } else { Err(Error::Argument) }+ }++ /// The C side's surface.+ fn on_cpp(&self) -> Result<ffi::ssi::SurfaceHandle> {+ init()?;+ match self {+ Spec::Plane { origin, xaxis, yaxis, u, v } => ffi::ssi::plane(origin, xaxis, yaxis, u, v),+ Spec::Cylinder { origin, xaxis, yaxis, radius, angle_deg, height } => {+ ffi::ssi::cylinder(origin, xaxis, yaxis, *radius, angle_deg, height)+ }+ Spec::Cone { apex, xaxis, yaxis, half_angle_deg, height } => ffi::ssi::cone(apex, xaxis, yaxis, *half_angle_deg, height),+ Spec::Sphere { center, xaxis, yaxis, radius, lon_deg, lat_deg } => ffi::ssi::sphere(center, xaxis, yaxis, *radius, lon_deg, lat_deg),+ Spec::Torus { center, xaxis, yaxis, major_radius, minor_radius, major_deg, minor_deg } => {+ ffi::ssi::torus(center, xaxis, yaxis, *major_radius, *minor_radius, major_deg, minor_deg)+ }+ Spec::Nurbs { degree, nu, nv, knots_u, knots_v, points, weights } => {+ let flat: Vec<f64> = points.iter().flatten().copied().collect();+ ffi::ssi::nurbs([int(degree[0])?, int(degree[1])?], int(*nu)?, int(*nv)?, knots_u, knots_v, &flat, weights.as_deref())+ }+ }+ .map_err(error)+ }+}++/// Whether intersections run on the C++ kernel ([`route::backend`]).+fn ssi_on_cpp() -> bool {+ route::backend() == route::Backend::Smlib+}+impl Surface {- pub(crate) fn handle(&self) -> &ffi::ssi::SurfaceHandle {- &self.0+ /// The C side's surface, made the first time the C++ kernel needs it.+ pub(crate) fn handle(&self) -> Result<&ffi::ssi::SurfaceHandle> {+ self.handle.get_or_init(|| self.spec.on_cpp()).as_ref().map_err(Clone::clone)+ }++ /// solidcore's surface, made the first time it is needed.+ fn core(&self) -> Result<&crate::core::split::Tool> {+ self.core.get_or_init(|| crate::core::ssi::surface(&self.spec)).as_ref().map_err(Clone::clone)+ }++ pub(crate) fn spec(&self) -> &Spec {+ &self.spec+ }++ /// A surface from its checked description. On the C+++ /// kernel, its side is made now, so that what it refuses is refused here.+ fn made(spec: Spec) -> Result<Surface> {+ spec.check()?;+ let s = Surface { handle: OnceLock::new(), core: OnceLock::new(), spec };+ if ssi_on_cpp() {+ s.handle()?;+ }+ Ok(s)}/// `origin + u*x + v*y` (x, y the axes made unit), for u in `u`, v in `v`.pub fn plane(origin: [f64; 3], xaxis: [f64; 3], yaxis: [f64; 3], u: [f64; 2], v: [f64; 2]) -> Result<Surface> {- init()?;- ffi::ssi::plane(&origin, &xaxis, &yaxis, &u, &v).map(Surface).map_err(error)+ Surface::made(Spec::Plane { origin, xaxis, yaxis, u, v })}/// A cylinder of `radius` about the axis through `origin` along `xaxis × yaxis`, angle/// `angle_deg` from `xaxis` towards `yaxis`, for heights `height` measured from `origin`.pub fn cylinder(origin: [f64; 3], xaxis: [f64; 3], yaxis: [f64; 3], radius: f64, angle_deg: [f64; 2], height: [f64; 2]) -> Result<Surface> {- init()?;- ffi::ssi::cylinder(&origin, &xaxis, &yaxis, radius, &angle_deg, &height).map(Surface).map_err(error)+ Surface::made(Spec::Cylinder { origin, xaxis, yaxis, radius, angle_deg, height })}/// A full cone with its apex at `apex` along `xaxis × yaxis`, radius `h * tan(half_angle_deg)`/// at distance h along the axis, for h in `height` (from 0: through the apex).pub fn cone(apex: [f64; 3], xaxis: [f64; 3], yaxis: [f64; 3], half_angle_deg: f64, height: [f64; 2]) -> Result<Surface> {- init()?;- ffi::ssi::cone(&apex, &xaxis, &yaxis, half_angle_deg, &height).map(Surface).map_err(error)+ Surface::made(Spec::Cone { apex, xaxis, yaxis, half_angle_deg, height })}/// A sphere of `radius` at `center`, over longitudes `lon_deg` and latitudes `lat_deg`.pub fn sphere(center: [f64; 3], xaxis: [f64; 3], yaxis: [f64; 3], radius: f64, lon_deg: [f64; 2], lat_deg: [f64; 2]) -> Result<Surface> {- init()?;- ffi::ssi::sphere(¢er, &xaxis, &yaxis, radius, &lon_deg, &lat_deg).map(Surface).map_err(error)+ Surface::made(Spec::Sphere { center, xaxis, yaxis, radius, lon_deg, lat_deg })}/// A ring torus at `center` about `xaxis × yaxis`, `major_deg` round the axis and `minor_deg`@@ -65,8 +216,7 @@ impl Surface {major_deg: [f64; 2],minor_deg: [f64; 2],) -> Result<Surface> {- init()?;- ffi::ssi::torus(¢er, &xaxis, &yaxis, major_radius, minor_radius, &major_deg, &minor_deg).map(Surface).map_err(error)+ Surface::made(Spec::Torus { center, xaxis, yaxis, major_radius, minor_radius, major_deg, minor_deg })}/// A (rational) B-spline surface: `nu × nv` control points, point (i, j) (i along u) at@@ -80,9 +230,15 @@ impl Surface {points: &[[f64; 3]],weights: Option<&[f64]>,) -> Result<Surface> {- init()?;- let flat: Vec<f64> = points.iter().flatten().copied().collect();- ffi::ssi::nurbs([int(degree[0])?, int(degree[1])?], int(nu)?, int(nv)?, knots_u, knots_v, &flat, weights).map(Surface).map_err(error)+ Surface::made(Spec::Nurbs {+ degree,+ nu,+ nv,+ knots_u: knots_u.to_vec(),+ knots_v: knots_v.to_vec(),+ points: points.to_vec(),+ weights: weights.map(<[f64]>::to_vec),+ })}/// A schema 4 record surface over the parameter box `domain` (`[[u0, u1], [v0, v1]]`, the@@ -142,12 +298,18 @@ impl Surface {/// The UV domain the intersection runs within, as `[u0, u1, v0, v1]`.pub fn domain(&self) -> Result<[f64; 4]> {- ffi::ssi::domain(&self.0).map_err(error)+ if !ssi_on_cpp() {+ return self.core().map(crate::core::ssi::domain);+ }+ ffi::ssi::domain(self.handle()?).map_err(error)}/// The surface's point at (u, v).pub fn evaluate(&self, u: f64, v: f64) -> Result<[f64; 3]> {- ffi::ssi::evaluate(&self.0, u, v).map_err(error)+ if !ssi_on_cpp() {+ return crate::core::ssi::evaluate(self.core()?, u, v);+ }+ ffi::ssi::evaluate(self.handle()?, u, v).map_err(error)}}@@ -158,8 +320,6 @@ pub enum Method {Global,/// `SmAdvSurfaceIntersector`, the general NURBS path.Advanced,- /// `SmSurfaceIntersector`, the basic intersector.- Basic,}impl Method {@@ -167,7 +327,6 @@ impl Method {match self {Method::Global => 0,Method::Advanced => 1,- Method::Basic => 2,}}}@@ -244,7 +403,7 @@ pub struct SsiResult {}/// The 3D B-spline: polynomial where every weight is 1.-fn curve3(c: ffi::ssi::Nurbs) -> b::Curve {+pub(crate) fn curve3(c: ffi::ssi::Nurbs) -> b::Curve {let points = c.points.as_chunks::<3>().0;if c.weights.iter().all(|w| *w == 1.0) {b::Curve::Spline { knots: c.knots, points: points.to_vec() }@@ -257,7 +416,7 @@ fn curve3(c: ffi::ssi::Nurbs) -> b::Curve {}/// A UV B-spline, as [`curve3`].-fn curve2(c: ffi::ssi::Nurbs) -> b::Curve2 {+pub(crate) fn curve2(c: ffi::ssi::Nurbs) -> b::Curve2 {let points = c.points.as_chunks::<2>().0;if c.weights.iter().all(|w| *w == 1.0) {b::Curve2::Spline { knots: c.knots, points: points.to_vec() }@@ -279,7 +438,10 @@ fn uv(r: &ffi::ssi::ResultHandle, i: i32, which: i32) -> Result<Option<b::Curve2/// `approx_tol` (<= 0: SMLib's default, 1/1000 of the surfaces' size). An intersector failure is/// SMLib's status; a curve SMLib does not hold as a B-spline is [`Error::Unsupported`].pub fn intersect(a: &Surface, b: &Surface, method: Method, approx_tol: f64) -> Result<SsiResult> {- let r = ffi::ssi::ssi(&a.0, &b.0, method.code(), approx_tol).map_err(error)?;+ if !ssi_on_cpp() {+ return crate::core::ssi::intersect(a.core()?, b.core()?, method, approx_tol);+ }+ let r = ffi::ssi::ssi(a.handle()?, b.handle()?, method.code(), approx_tol).map_err(error)?;let n = ffi::ssi::curve_count(&r).map_err(error)?;let mut curves = Vec::new();for i in 0..n {@@ -309,6 +471,8 @@ mod tests {/// A plane through a sphere's centre: one great circle.#[test]fn plane_through_sphere_is_a_circle() {+ #[cfg(feature = "native")]+ let _cpp = route::on_cpp();let z = [0.0, 0.0, 1.0];let (x, y) = ([1.0, 0.0, 0.0], [0.0, 1.0, 0.0]);let plane = Surface::plane([0.0; 3], x, y, [-2.0, 2.0], [-2.0, 2.0]);@@ -330,15 +494,52 @@ mod tests {}}+ /// Refused here, before any kernel: alike on either, and with no C++ kernel.#[test]fn bad_input_is_an_argument_error() {- match Surface::plane([0.0; 3], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0], [0.0, 1.0]) {- Err(Error::NotBuilt) => {}- r => assert_eq!(r.err(), Some(Error::Argument)),+ let (x, y) = ([1.0, 0.0, 0.0], [0.0, 1.0, 0.0]);+ let refused = [+ Surface::plane([0.0; 3], x, x, [0.0, 1.0], [0.0, 1.0]),+ Surface::plane([0.0; 3], x, y, [1.0, 0.0], [0.0, 1.0]),+ Surface::plane([f64::NAN; 3], x, y, [0.0, 1.0], [0.0, 1.0]),+ Surface::cylinder([0.0; 3], x, y, 0.0, [0.0, 360.0], [0.0, 1.0]),+ Surface::cone([0.0; 3], x, y, f64::NAN, [0.0, 1.0]),+ Surface::sphere([0.0; 3], x, y, 1.0, [0.0, 360.0], [-91.0, 90.0]),+ Surface::torus([0.0; 3], x, y, 1.0, 2.0, [0.0, 360.0], [0.0, 360.0]),+ Surface::nurbs([1, 1], 2, 2, &[0.0, 0.0, 1.0, 1.0], &[0.0, 0.0, 1.0, 1.0], &[[0.0; 3]; 3], None),+ Surface::nurbs([1, 1], 2, 2, &[0.0, 0.0, 1.0], &[0.0, 0.0, 1.0, 1.0], &[[0.0; 3]; 4], None),+ Surface::nurbs([1, 1], 2, 2, &[0.0, 0.0, 1.0, 1.0], &[0.0, 0.0, 1.0, 1.0], &[[0.0; 3]; 4], Some(&[0.0; 4])),+ Surface::nurbs([0, 1], 2, 2, &[0.0, 0.0, 1.0], &[0.0, 0.0, 1.0, 1.0], &[[0.0; 3]; 4], None),+ ];+ for (i, r) in refused.iter().enumerate() {+ assert_eq!(r.as_ref().err(), Some(&Error::Argument), "{i}");}- match Surface::nurbs([1, 1], 2, 2, &[0.0, 0.0, 1.0, 1.0], &[0.0, 0.0, 1.0, 1.0], &[[0.0; 3]; 3], None) {- Err(Error::NotBuilt) => {}- r => assert_eq!(r.err(), Some(Error::Argument)),+ }++ /// On solidcore a surface needs no C++ kernel, and answers by itself. The basic intersector is+ /// the one method solidcore has no public entry for, and it says so; nothing falls back.+ #[test]+ fn surfaces_on_solidcore_answer_without_the_cpp_kernel() {+ if ssi_on_cpp() {+ return;+ }+ let (x, y, z) = ([1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]);+ let plane = Surface::plane([0.0; 3], x, y, [-2.0, 2.0], [-3.0, 3.0]).unwrap();+ assert_eq!(plane.domain().unwrap(), [-2.0, 2.0, -3.0, 3.0]);+ assert_eq!(plane.evaluate(1.0, -2.0).unwrap(), [1.0, -2.0, 0.0]);+ assert_eq!(plane.evaluate(f64::NAN, 0.0).unwrap_err(), Error::Argument);+ let sphere = Surface::sphere([0.0; 3], x, z, 1.0, [0.0, 360.0], [-90.0, 90.0]).unwrap();+ for method in [Method::Global, Method::Advanced] {+ let r = intersect(&plane, &sphere, method, 1e-6).unwrap();+ assert!(!r.curves.is_empty(), "{method:?}");+ for c in &r.curves {+ let eval = b::eval::CurveEval::new(&c.curve).unwrap();+ let [t0, t1] = c.interval;+ for k in 0..=100 {+ let p = eval.point(t0 + (t1 - t0) * f64::from(k) / 100.0).unwrap();+ assert!((p.x.hypot(p.y) - 1.0).abs() < 1e-5 && p.z.abs() < 1e-5, "{method:?}: {p:?}");+ }+ }}}}diff --git a/crates/smlib/src/sweeps.rs b/crates/smlib/src/sweeps.rsindex e13055242e..c2c040034b 100644--- a/crates/smlib/src/sweeps.rs+++ b/crates/smlib/src/sweeps.rs@@ -6,7 +6,7 @@//! With `cap`, the profile's loops close the ends and the result must be a closed manifold solid//! ([`Error::NotSolid`] otherwise); without, it is the swept sheet.-use crate::{Brep, Error, Result, error, ffi, init};+use crate::{Brep, Error, Result, core, error, ffi, init, route};/// A 3D curve of a profile, path or section.#[derive(Clone, Debug, PartialEq)]@@ -99,13 +99,13 @@ pub const MAX_CURVES: usize = ffi::sweeps::CURVE_MAX_CURVES;/// The curves as the C API's curve list.#[derive(Default)]-struct List {+pub(crate) struct List {kinds: Vec<i64>,reals: Vec<f64>,}impl List {- fn of<'a>(curves: impl IntoIterator<Item = &'a Curve>) -> Result<List> {+ pub(crate) fn of<'a>(curves: impl IntoIterator<Item = &'a Curve>) -> Result<List> {let mut l = List::default();for c in curves {l.push(c)?;@@ -150,18 +150,36 @@ impl List {Ok(())}- fn raw(&self) -> ffi::sweeps::List<'_> {+ pub(crate) fn raw(&self) -> ffi::sweeps::List<'_> {ffi::sweeps::List::new(&self.kinds, &self.reals)}}+#[cfg(test)]+thread_local! {+ /// Tests: this thread's sweeps run on the C++ kernel whatever the choice.+ pub(crate) static ON_CPP: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };+}++/// Whether the sweeps run on solidcore ([`route::backend`]).+fn on_core() -> bool {+ #[cfg(test)]+ if ON_CPP.with(std::cell::Cell::get) {+ return false;+ }+ route::backend() == route::Backend::Solidcore+}+impl Brep {/// A sheet of planar faces bounded by `loops`: closed loops of curves in one plane, in any/// order, nested as outer loops, their holes and islands in the holes.pub fn planar_faces(loops: &[Curve]) -> Result<Brep> {+ if on_core() {+ return core::sweep::planar_faces(loops).map(Brep::made_core);+ }init()?;let l = List::of(loops)?;- ffi::sweeps::planar_faces(&l.raw()).map(Brep).map_err(error)+ ffi::sweeps::planar_faces(&l.raw()).map(Brep::made).map_err(error)}/// The planar `profile` extruded `distance` along the unit `direction` (square to its plane).@@ -172,6 +190,9 @@ impl Brep {/// [`DraftCorner::Curvature`], a curve of a profile with a sharp corner is neither a line nor/// an arc).pub fn extrude(profile: &[Curve], direction: [f64; 3], distance: f64, draft: f64, corner: DraftCorner, cap: bool) -> Result<Brep> {+ if on_core() {+ return core::sweep::extrude(profile, direction, distance, draft, corner, cap).map(Brep::made_core);+ }init()?;let l = List::of(profile)?;let rule = match corner {@@ -180,7 +201,7 @@ impl Brep {DraftCorner::Round => ffi::sweeps::DRAFT_CORNER_ROUND,};let mut at = [f64::NAN; 3];- ffi::sweeps::extrude(&l.raw(), &direction, distance, draft, rule, cap, &mut at).map(Brep).map_err(|s| {+ ffi::sweeps::extrude(&l.raw(), &direction, distance, draft, rule, cap, &mut at).map(Brep::made).map_err(|s| {let why = match s {ffi::sweeps::ERR_CORNER_APART => Some(CornerRefusal::Apart),ffi::sweeps::ERR_WALL_CLOSES => Some(CornerRefusal::WallCloses),@@ -197,22 +218,28 @@ impl Brep {/// The planar `profile` turned `angle` radians (0 < angle <= 2 pi) right-handed about the/// axis through `origin` along `direction`, in the profile's plane (touching it at most).pub fn revolve(profile: &[Curve], origin: [f64; 3], direction: [f64; 3], angle: f64, cap: bool) -> Result<Brep> {+ if on_core() {+ return core::sweep::revolve(profile, origin, direction, angle, cap).map(Brep::made_core);+ }init()?;let l = List::of(profile)?;- ffi::sweeps::revolve(&l.raw(), &origin, &direction, angle, cap).map(Brep).map_err(error)+ ffi::sweeps::revolve(&l.raw(), &origin, &direction, angle, cap).map(Brep::made).map_err(error)}/// `profile` swept along `path` (end-to-end curves), carried with the path's start: the/// profile keeps its place relative to it. The walls are B-spline approximations, one per/// stretch of profile between tangent breaks.pub fn sweep(profile: &[Curve], path: &[Curve], frame: SweepFrame, cap: bool) -> Result<Brep> {+ if on_core() {+ return core::sweep::sweep_placed(profile, path, frame, cap).map(|(b, _)| Brep::made_core(b));+ }init()?;let (l, p) = (List::of(profile)?, List::of(path)?);let frame = match frame {SweepFrame::Follow => ffi::sweeps::SWEEP_FOLLOW,SweepFrame::Translate => ffi::sweeps::SWEEP_TRANSLATE,};- ffi::sweeps::sweep(&l.raw(), &p.raw(), frame, cap).map(Brep).map_err(error)+ ffi::sweeps::sweep(&l.raw(), &p.raw(), frame, cap).map(Brep::made).map_err(error)}/// [`Brep::sweep`], with where the sweep placed the profile: the rigid motions carrying the@@ -221,6 +248,9 @@ impl Brep {/// out from point to point along the path); a sweep that carries on from where this one left/// the profile starts from the last.pub fn sweep_placed(profile: &[Curve], path: &[Curve], frame: SweepFrame, cap: bool) -> Result<(Brep, [Affine; 3])> {+ if on_core() {+ return core::sweep::sweep_placed(profile, path, frame, cap).map(|(b, m)| (Brep::made_core(b), m));+ }init()?;let (l, p) = (List::of(profile)?, List::of(path)?);let frame = match frame {@@ -228,7 +258,7 @@ impl Brep {SweepFrame::Translate => ffi::sweeps::SWEEP_TRANSLATE,};let mut placed = [0.0; 36];- let brep = ffi::sweeps::sweep_placed(&l.raw(), &p.raw(), frame, cap, &mut placed).map(Brep).map_err(error)?;+ let brep = ffi::sweeps::sweep_placed(&l.raw(), &p.raw(), frame, cap, &mut placed).map(Brep::made).map_err(error)?;let motion = |i: usize| {let at = |k: usize| placed.get(12 * i + k).copied().unwrap_or(0.0);Affine { m: [[at(0), at(1), at(2)], [at(3), at(4), at(5)], [at(6), at(7), at(8)]], t: [at(9), at(10), at(11)] }@@ -249,9 +279,12 @@ impl Brep {direction: [f64; 3],tolerance: f64,) -> Result<Vec<(Curve, [f64; 2])>> {+ if on_core() {+ return core::sweep::project_curves(self.core()?, face_point, pick_tolerance, curves, direction, tolerance);+ }init()?;let l = List::of(curves)?;- let out = ffi::sweeps::project_curves(&self.0, &face_point, pick_tolerance, &l.raw(), &direction, tolerance).map_err(picked)?;+ let out = ffi::sweeps::project_curves(self.cpp()?, &face_point, pick_tolerance, &l.raw(), &direction, tolerance).map_err(picked)?;nurbs_list(&out)}@@ -265,14 +298,20 @@ impl Brep {plane_normal: [f64; 3],tolerance: f64,) -> Result<Vec<(Curve, [f64; 2])>> {+ if on_core() {+ return core::sweep::face_section(self.core()?, face_point, pick_tolerance, plane_point, plane_normal, tolerance);+ }init()?;- let out = ffi::sweeps::face_section(&self.0, &face_point, pick_tolerance, &plane_point, &plane_normal, tolerance).map_err(picked)?;+ let out = ffi::sweeps::face_section(self.cpp()?, &face_point, pick_tolerance, &plane_point, &plane_normal, tolerance).map_err(picked)?;nurbs_list(&out)}/// A loft (skin) through `sections` (at least two closed loops), `degree` (1 ruled, 2 or 3)/// across them.pub fn loft(sections: &[Vec<Curve>], degree: u32, cap: bool) -> Result<Brep> {+ if on_core() {+ return core::sweep::loft(sections, degree, cap).map(Brep::made_core);+ }init()?;if sections.len() < 2 || sections.len() > MAX_CURVES || !(1..=3).contains(°ree) {return Err(Error::Argument);@@ -280,13 +319,16 @@ impl Brep {let l = List::of(sections.iter().flatten())?;let sizes: Vec<i64> = sections.iter().map(|s| i64::try_from(s.len()).map_err(|_| Error::Argument)).collect::<Result<_>>()?;let degree = i32::try_from(degree).map_err(|_| Error::Argument)?;- ffi::sweeps::loft(&l.raw(), &sizes, degree, cap).map(Brep).map_err(error)+ ffi::sweeps::loft(&l.raw(), &sizes, degree, cap).map(Brep::made).map_err(error)}/// The planar `profile` placed by each of `stations` in turn (2…[`MAX_STATIONS`], each/// section exactly the profile's image), its walls skinned through the sections, cubic/// across them: one wall per profile curve. `ends` says how the ends close.pub fn sweep_stations(profile: &[Curve], stations: &[Affine], ends: Ends) -> Result<Brep> {+ if on_core() {+ return core::sweep::sweep_stations(profile, stations, ends).map(Brep::made_core);+ }init()?;if !(2..=MAX_STATIONS).contains(&stations.len()) || profile.len().saturating_mul(stations.len()) > MAX_STATION_CURVES {return Err(Error::Argument);@@ -298,24 +340,30 @@ impl Brep {Ends::Capped => ffi::sweeps::ENDS_CAPPED,Ends::Joined => ffi::sweeps::ENDS_JOINED,};- ffi::sweeps::sweep_stations(&l.raw(), &maps, ends).map(Brep).map_err(error)+ ffi::sweeps::sweep_stations(&l.raw(), &maps, ends).map(Brep::made).map_err(error)}/// A loft from the planar `section` (one closed loop of lines, in order) to the point `apex`/// off its plane: a pyramid, its base the section and a triangle on each line.pub fn loft_to_point(section: &[Curve], apex: [f64; 3]) -> Result<Brep> {+ if on_core() {+ return core::sweep::loft_to_point(section, apex).map(Brep::made_core);+ }init()?;let l = List::of(section)?;- ffi::sweeps::loft_to_point(&l.raw(), &apex).map(Brep).map_err(error)+ ffi::sweeps::loft_to_point(&l.raw(), &apex).map(Brep::made).map_err(error)}/// `profile` carried by a screw motion about the axis through `origin` along `direction`:/// `turns` right-handed turns about it, rising `pitch` (signed) per turn, capped at both ends,/// its walls within about `tolerance` of the true screw surfaces.pub fn screw_sweep(profile: &[Curve], origin: [f64; 3], direction: [f64; 3], pitch: f64, turns: f64, tolerance: f64) -> Result<Brep> {+ if on_core() {+ return core::sweep::screw_sweep(profile, origin, direction, pitch, turns, None, tolerance).map(Brep::made_core);+ }init()?;let l = List::of(profile)?;- ffi::sweeps::screw_sweep(&l.raw(), &origin, &direction, pitch, turns, tolerance).map(Brep).map_err(error)+ ffi::sweeps::screw_sweep(&l.raw(), &origin, &direction, pitch, turns, tolerance).map(Brep::made).map_err(error)}/// [`screw_sweep`](Self::screw_sweep) with the profile moved off the axis as it turns: at turn@@ -333,10 +381,13 @@ impl Brep {law: &[(f64, f64)],tolerance: f64,) -> Result<Brep> {+ if on_core() {+ return core::sweep::screw_sweep(profile, origin, direction, pitch, turns, Some(law), tolerance).map(Brep::made_core);+ }init()?;let l = List::of(profile)?;let flat: Vec<f64> = law.iter().flat_map(|(t, o)| [*t, *o]).collect();- ffi::sweeps::screw_sweep_radial(&l.raw(), &origin, &direction, pitch, turns, &flat, tolerance).map(Brep).map_err(error)+ ffi::sweeps::screw_sweep_radial(&l.raw(), &origin, &direction, pitch, turns, &flat, tolerance).map(Brep::made).map_err(error)}}diff --git a/crates/smlib/src/tests.rs b/crates/smlib/src/tests.rsindex 5125cc58e9..41ac8e13e7 100644--- a/crates/smlib/src/tests.rs+++ b/crates/smlib/src/tests.rs@@ -9,7 +9,8 @@ fn box_end_to_end() {let c = b.try_clone().unwrap();drop(b);assert!((c.volume(1e-7).unwrap() - 6000.0).abs() < 1e-6);- assert_eq!(current_call(), None, "no call in flight between calls");+ let mut buf = [0u8; 512];+ assert_eq!(ffi::current_call(&mut buf), 0, "no C call in flight between calls");}#[cfg(feature = "native")]@@ -17,13 +18,86 @@ fn box_end_to_end() {fn bad_arguments_are_errors() {assert_eq!(Brep::make_box([0.0; 3], [1.0, -1.0, 1.0]).unwrap_err(), Error::Argument);assert_eq!(Brep::make_box([f64::NAN, 0.0, 0.0], [1.0; 3]).unwrap_err(), Error::Argument);+ // each kernel refuses a bad box the same way, whichever one is in force+ init().unwrap();+ for size in [[1.0, -1.0, 1.0], [1.0, 0.0, 1.0], [1.0, 1.0, f64::NAN]] {+ assert_eq!(core::make_box([0.0; 3], size).err(), Some(Error::Argument), "solidcore: {size:?}");+ assert_eq!(ffi::make_box(&[0.0; 3], &size).map_err(error).err(), Some(Error::Argument), "C++: {size:?}");+ }let b = Brep::make_box([0.0; 3], [1.0; 3]).unwrap();assert_eq!(b.volume(f64::INFINITY).unwrap_err(), Error::Argument);}+/// `.smb` files on solidcore, in both forms and with a curved body, and a missing or corrupt file+/// is an error, not a panic.+#[test]+fn solidcore_reads_back_the_files_it_writes() {+ use std::f64::consts::PI;+ let dir = std::env::temp_dir().join(format!("solidcraft-smlib-core-file-{}", std::process::id()));+ std::fs::create_dir_all(&dir).unwrap();+ let cylinder = core::make_cylinder([1.0, 2.0, 3.0], 2.0, 5.0).map(Brep::made_core).unwrap();+ for ascii in [false, true] {+ let path = dir.join(format!("cylinder-{ascii}.smb"));+ core::file::write(cylinder.core().unwrap(), &path, ascii).unwrap();+ let back = core::file::read(&path, ascii).map(Brep::made_core).unwrap();+ let v = core::volume(back.core().unwrap(), 1e-7).unwrap();+ assert!((v - PI * 4.0 * 5.0).abs() < 1e-5, "ascii {ascii}: {v}");+ assert_eq!(core::counts(back.core().unwrap()).unwrap(), core::counts(cylinder.core().unwrap()).unwrap(), "ascii {ascii}");+ }+ let body = cylinder.core().unwrap();+ assert!(core::file::write(body, &dir.join("missing/x.smb"), false).is_err());+ assert!(core::file::read(&dir.join("missing.smb"), false).is_err());+ let junk = dir.join("junk.smb");+ std::fs::write(&junk, b"not a B-rep file").unwrap();+ assert!(core::file::read(&junk, false).is_err());+ let _ = std::fs::remove_dir_all(&dir);+}++/// ASCII that is no B-rep file is refused like binary. It comes back as an empty body today:+/// default-solidcore/bugs/ascii-junk-reads-as-empty.md.+#[test]+#[ignore = "solidcore: an ASCII file of junk reads as an empty B-rep instead of an error"]+fn solidcore_refuses_an_ascii_file_of_junk() {+ let dir = std::env::temp_dir().join(format!("solidcraft-smlib-core-junk-{}", std::process::id()));+ std::fs::create_dir_all(&dir).unwrap();+ let junk = dir.join("junk.smb");+ std::fs::write(&junk, b"not a B-rep file").unwrap();+ let r = core::file::read(&junk, true);+ let _ = std::fs::remove_dir_all(&dir);+ assert!(r.is_err());+}++/// A file either kernel wrote reads on the other, with the same measure.+#[cfg(feature = "native")]+#[test]+fn each_kernel_reads_the_files_of_the_other() {+ use std::f64::consts::PI;+ let dir = std::env::temp_dir().join(format!("solidcraft-smlib-cross-file-{}", std::process::id()));+ std::fs::create_dir_all(&dir).unwrap();+ let want = PI * 4.0 * 5.0;+ for ascii in [false, true] {+ let from_core = dir.join(format!("core-{ascii}.smb"));+ let body = core::make_cylinder([0.0; 3], 2.0, 5.0).unwrap();+ core::file::write(&body, &from_core, ascii).unwrap();+ crate::init().unwrap();+ let on_cpp = ffi::read(&c_path(&from_core).unwrap(), ascii).map(Brep::made).unwrap();+ let v = ffi::volume(on_cpp.cpp().unwrap(), 1e-7).unwrap();+ assert!((v - want).abs() < 1e-5, "C++ on solidcore's file, ascii {ascii}: {v}");+ let from_cpp = dir.join(format!("cpp-{ascii}.smb"));+ let cpp = ffi::make_cylinder(&[0.0; 3], 2.0, 5.0).map(Brep::made).unwrap();+ crate::check(ffi::write(cpp.cpp().unwrap(), &c_path(&from_cpp).unwrap(), ascii)).unwrap();+ let on_core = core::file::read(&from_cpp, ascii).unwrap();+ let v = core::volume(&on_core, 1e-7).unwrap();+ assert!((v - want).abs() < 1e-5, "solidcore on C++'s file, ascii {ascii}: {v}");+ }+ let _ = std::fs::remove_dir_all(&dir);+}+#[cfg(feature = "native")]#[test]fn native_files_round_trip_and_failures_dump_their_inputs() {+ let _dumps = DUMP_DIR_TESTS.lock().unwrap_or_else(std::sync::PoisonError::into_inner);+ let _cpp = route::on_cpp();let dir = std::env::temp_dir().join(format!("solidcraft-smlib-test-{}", std::process::id()));std::fs::create_dir_all(&dir).unwrap();let b = Brep::make_box([0.0; 3], [2.0, 3.0, 4.0]).unwrap();@@ -65,8 +139,265 @@ fn calls_from_many_threads_are_serialised() {#[test]fn without_native_every_call_says_so() {assert_eq!(init(), Err(Error::NotBuilt));- assert_eq!(Brep::make_box([0.0; 3], [1.0; 3]).unwrap_err(), Error::NotBuilt);- assert_eq!(current_call(), None);+ // the C API's own box, whichever kernel is in force+ assert_eq!(ffi::make_box(&[0.0; 3], &[1.0; 3]).map_err(error).err(), Some(Error::NotBuilt));+ // solidcore builds a box without SMLib; asking the C++ kernel about it says there is none+ let b = core::make_box([0.0; 3], [1.0; 3]).map(Brep::made_core).unwrap();+ assert_eq!(b.cpp().err(), Some(Error::NotBuilt));+ // and says how to get it+ assert!(!built());+ assert!(Error::NotBuilt.to_string().contains("--features smlib"), "{}", Error::NotBuilt);+}++/// The dump folder is process-wide: the tests that set it take turns.+static DUMP_DIR_TESTS: std::sync::Mutex<()> = std::sync::Mutex::new(());++/// Which public entry points work with no C++ kernel: all of them but [`CPP_ONLY`], which are the+/// C++ kernel's own arrays and start-up, reached only across kernels and by tests. A new entry point+/// fails [`every_entry_point_is_in_the_guard`] until it is called in the test below or listed.+const CPP_ONLY: [&str; 8] = ["init", "new", "get_i64", "get_f64", "set_i64", "set_f64", "import", "export"];++/// Entry points that ask no kernel, so have nothing to say here.+const NO_KERNEL: [&str; 11] = [+ "inertia_tensor",+ "is_valid",+ "failed_tests",+ "native",+ "arrays_keeping_splines",+ "from_arrays",+ "from_record_keeping_splines",+ "to_native_report",+ "to_native_ordered",+ "blends",+ // The last refusal's fit, read after it: on solidcore, none yet.+ "blend_fit",+];++const ANSWERING: [&str; 62] = [+ "set_dump_dir",+ "current_call",+ "make_box",+ "read",+ "write",+ "try_clone",+ "transformed",+ "volume",+ "counts",+ "boolean",+ "union_all",+ "boolean2d",+ "imprint",+ "solid_count",+ "fillet",+ "chamfer",+ "blend",+ "blend_dropping",+ "blend_setback",+ "blend_setback_open",+ "fillet_variable",+ "chamfer_sides",+ "shell",+ "offset_faces",+ "thicken",+ "merge_faces",+ "draft",+ "split_faces",+ "split_body",+ "split_body_by_sheet",+ "untrim_face",+ "extend_sheet",+ "face_points",+ "stitch",+ "offset_sheet",+ "classify_point",+ "mass_properties",+ "bounds",+ "edge_face_distance",+ "area",+ "is_manifold_solid",+ "tagged",+ "history",+ "check",+ "make_cylinder",+ "make_sphere",+ "make_cone",+ "make_torus",+ "arrays",+ "to_native",+ "planar_faces",+ "extrude",+ "revolve",+ "sweep",+ "sweep_placed",+ "project_curves",+ "face_section",+ "loft",+ "sweep_stations",+ "loft_to_point",+ "screw_sweep",+ "screw_sweep_radial",+];++/// Every `pub fn` of the files that hold the crate's kernel entry points is accounted for.+#[test]+fn every_entry_point_is_in_the_guard() {+ let files = [+ include_str!("lib.rs"),+ include_str!("ops.rs"),+ include_str!("split.rs"),+ include_str!("trim.rs"),+ include_str!("sheets.rs"),+ include_str!("measure.rs"),+ include_str!("flat.rs"),+ include_str!("history.rs"),+ include_str!("check.rs"),+ include_str!("sweeps.rs"),+ include_str!("export.rs"),+ ];+ for file in files {+ for line in file.lines() {+ let Some(rest) = line.trim_start().strip_prefix("pub fn ") else { continue };+ let name = rest.split(['(', '<']).next().unwrap_or(rest);+ assert!(ANSWERING.contains(&name) || CPP_ONLY.contains(&name) || NO_KERNEL.contains(&name), "`{name}` is in neither list");+ }+ }+}++/// With no C++ kernel, each entry point answers with something other than "not built": its result+/// or its own refusal, on a body of the right kind or the wrong one. Built with the C++ kernel, the+/// same calls with nothing chosen never touch a C++ body: nothing on the default path reaches it.+#[test]+fn without_the_cpp_kernel_every_entry_point_answers() {+ use crate::sweeps::{Affine, Curve, DraftCorner, Ends, SweepFrame};+ use crate::trim::{Continuation, Holes};+ use crate::{Blend, BooleanOp, ChamferSecond, CheckLevel};+ if route::backend() != route::Backend::Solidcore {+ return;+ }+ fn says<T>(name: &str, r: Result<T>) -> Option<T> {+ match r {+ Err(Error::NotBuilt) => panic!("{name} needs the C++ kernel"),+ r => r.ok(),+ }+ }+ let dir = std::env::temp_dir().join(format!("solidcraft-smlib-guard-{}", std::process::id()));+ std::fs::create_dir_all(&dir).unwrap();+ {+ let _dumps = DUMP_DIR_TESTS.lock().unwrap_or_else(std::sync::PoisonError::into_inner);+ says("set_dump_dir", set_dump_dir(None));+ }+ let _ = current_call();+ route::take_reached();+ let a = says("make_box", Brep::make_box([0.0; 3], [10.0; 3])).unwrap();+ let t = says("make_box", Brep::make_box([5.0; 3], [10.0; 3])).unwrap();+ let p = |x: f64, y: f64, z: f64| [x, y, z];+ let edge = [p(5.0, 10.0, 10.0)];+ let top = [p(5.0, 5.0, 10.0)];+ let path = dir.join("a.smb");+ says("write", a.write(&path, false));+ says("read", Brep::read(&path, false));+ says("try_clone", a.try_clone());+ says("transformed", a.transformed(&[[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]));+ says("volume", a.volume(1e-6));+ says("counts", a.counts());+ says("boolean", a.boolean(&t, BooleanOp::Union));+ says("union_all", Brep::union_all(&[&a, &t]));+ says("boolean2d", a.boolean2d(&t, BooleanOp::Union));+ says("imprint", a.imprint(&t));+ says("solid_count", a.solid_count());+ says("fillet", a.fillet(&edge, 0.1, 1.0));+ says("chamfer", a.chamfer(&edge, 0.1, 1.0));+ says("blend", a.blend(Blend::Round, &edge, &[1.0], 0.1));+ says("blend_dropping", a.blend_dropping(Blend::Round, &edge, &[1.0], 0.1));+ let corner = [p(10.0, 10.0, 10.0)];+ let three = [p(5.0, 10.0, 10.0), p(10.0, 5.0, 10.0), p(10.0, 10.0, 5.0)];+ says("blend_setback", a.blend_setback(Blend::Round, &three, &[1.0; 3], &corner, &[2.0], 0.1));+ says("blend_setback_open", a.blend_setback_open(Blend::Round, &three, &[1.0; 3], &corner, &[2.0], 0.1));+ says("fillet_variable", a.fillet_variable(edge[0], 0.1, p(0.0, 10.0, 10.0), 1, &[0.0, 0.0, 1.0, 1.0], &[2.0, 1.0]));+ says("chamfer_sides", a.chamfer_sides(&edge, 0.1, 1.0, ChamferSecond::Distance(2.0), p(0.0, 0.0, 1.0)));+ says("shell", a.shell(&top, 0.1, 1.0));+ says("offset_faces", a.offset_faces(&top, 0.1, 1.0));+ says("thicken", a.thicken(1.0, false));+ says("merge_faces", a.merge_faces(&top, 0.1));+ says("draft", a.draft(&[p(5.0, 10.0, 5.0)], 0.1, [0.0; 3], p(0.0, 0.0, 1.0), p(0.0, 0.0, 1.0), 0.1));+ let tool =+ says("Surface::plane", ssi::Surface::plane(p(0.0, 0.0, 5.0), p(1.0, 0.0, 0.0), p(0.0, 1.0, 0.0), [-50.0, 50.0], [-50.0, 50.0])).unwrap();+ says("split_faces", a.split_faces(&[0], &[&tool]));+ says("split_body", a.split_body(&tool));+ let square = [p(0.0, 0.0, 5.0), p(10.0, 0.0, 5.0), p(10.0, 10.0, 5.0), p(0.0, 10.0, 5.0)];+ let lines: Vec<Curve> = (0..4).map(|i| Curve::Line { start: square[i], end: square[(i + 1) % 4] }).collect();+ let sheet = says("planar_faces", Brep::planar_faces(&lines)).unwrap();+ says("split_body_by_sheet", a.split_body_by_sheet(&sheet, 0));+ says("untrim_face", sheet.untrim_face(p(5.0, 5.0, 5.0), 0.1, Holes::All, true, false));+ says("extend_sheet", sheet.extend_sheet(p(5.0, 5.0, 5.0), 0.1, 1.0, Continuation::Natural));+ says("face_points", a.face_points());+ says("stitch", sheet.stitch(0.1));+ says("offset_sheet", sheet.offset_sheet(1.0));+ says("classify_point", a.classify_point([1.0; 3]));+ says("mass_properties", a.mass_properties(1e-6));+ says("bounds", a.bounds());+ says("edge_face_distance", a.edge_face_distance(0, 0));+ says("area", a.area(1e-6));+ says("is_manifold_solid", a.is_manifold_solid());+ says("history", says("tagged", a.tagged(0)).unwrap().history());+ says("check", a.check(CheckLevel::All));+ says("make_cylinder", Brep::make_cylinder([0.0; 3], 1.0, 1.0));+ says("make_sphere", Brep::make_sphere([0.0; 3], 1.0));+ says("make_cone", Brep::make_cone([0.0; 3], 2.0, 1.0, 1.0));+ says("make_torus", Brep::make_torus([0.0; 3], 2.0, 1.0));+ says("arrays", a.arrays());+ says("to_native", a.to_native().map_err(|_| Error::Argument));+ says("extrude", Brep::extrude(&lines, p(0.0, 0.0, 1.0), 1.0, 0.0, DraftCorner::Curvature, true));+ says("revolve", Brep::revolve(&lines, p(20.0, 0.0, 0.0), p(0.0, 1.0, 0.0), 1.0, true));+ let run = [Curve::Line { start: p(5.0, 5.0, 5.0), end: p(5.0, 5.0, 15.0) }];+ says("sweep", Brep::sweep(&lines, &run, SweepFrame::Follow, true));+ says("sweep_placed", Brep::sweep_placed(&lines, &run, SweepFrame::Follow, true));+ says("project_curves", a.project_curves(top[0], 0.1, &lines, p(0.0, 0.0, -1.0), 0.01));+ says("face_section", a.face_section(top[0], 0.1, top[0], p(1.0, 0.0, 0.0), 0.01));+ let lifted: Vec<Curve> = (0..4)+ .map(|i| Curve::Line { start: [square[i][0], square[i][1], 9.0], end: [square[(i + 1) % 4][0], square[(i + 1) % 4][1], 9.0] })+ .collect();+ says("loft", Brep::loft(&[lines.clone(), lifted], 1, true));+ let i3 = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];+ says("sweep_stations", Brep::sweep_stations(&lines, &[Affine { m: i3, t: [0.0; 3] }, Affine { m: i3, t: [0.0, 0.0, 2.0] }], Ends::Capped));+ says("loft_to_point", Brep::loft_to_point(&lines, p(5.0, 5.0, 12.0)));+ says("screw_sweep", Brep::screw_sweep(&lines, p(30.0, 0.0, 0.0), p(0.0, 0.0, 1.0), 12.0, 1.0, 0.01));+ says("screw_sweep_radial", Brep::screw_sweep_radial(&lines, p(30.0, 0.0, 0.0), p(0.0, 0.0, 1.0), 12.0, 1.0, &[(0.0, 0.0), (1.0, 0.0)], 0.01));+ let (cpp, core) = route::take_reached();+ assert!(cpp == 0 && core > 0, "the default path touched a C++ body {cpp} times ({core} solidcore calls)");+ let _ = std::fs::remove_dir_all(&dir);+}++/// A failing solidcore call leaves its inputs and what failed, and an answered one leaves nothing;+/// the call in flight is named, and gone after. A folder is process-wide, so this test is the one+/// that sets it.+#[test]+fn a_failing_solidcore_call_leaves_a_dump_and_names_itself() {+ let _dumps = DUMP_DIR_TESTS.lock().unwrap_or_else(std::sync::PoisonError::into_inner);+ let dir = std::env::temp_dir().join(format!("solidcraft-smlib-core-dump-{}", std::process::id()));+ std::fs::create_dir_all(&dir).unwrap();+ core::dump::set_dir(Some(dir.clone()));+ let a = core::make_box([0.0; 3], [10.0; 3]).unwrap();+ let seen: std::sync::Mutex<Option<String>> = std::sync::Mutex::new(None);+ let r: Result<()> = core::with_body("smlib_test_failure", &a, |_, _| {+ *seen.lock().unwrap() = core::dump::current();+ Err(solidcore::SolidError::invalid_input("test", "refused"))+ });+ core::dump::set_dir(None);+ assert!(r.is_err());+ assert_eq!(seen.lock().unwrap().as_deref(), Some("smlib_test_failure"));+ {+ // Under the kernel's lock no solidcore call is in flight.+ let _kernel = core::KERNEL.lock().unwrap_or_else(std::sync::PoisonError::into_inner);+ assert_eq!(core::dump::current(), None);+ }+ let got: Vec<String> = std::fs::read_dir(&dir).unwrap().flatten().map(|e| e.file_name().to_string_lossy().into_owned()).collect();+ let text = got.iter().find(|n| n.ends_with("-smlib_test_failure.txt")).unwrap_or_else(|| panic!("{got:?}"));+ assert!(std::fs::read_to_string(dir.join(text)).unwrap().contains("refused"));+ let smb = got.iter().find(|n| n.ends_with("-smlib_test_failure-brep.smb")).unwrap_or_else(|| panic!("{got:?}"));+ let back = core::file::read(&dir.join(smb), false).unwrap();+ assert!((core::volume(&back, 1e-7).unwrap() - 1000.0).abs() < 1e-6);+ let _ = std::fs::remove_dir_all(&dir);}#[test]@@ -82,9 +413,12 @@ fn call_lines_give_the_function_and_the_c_api_time() {#[cfg(feature = "native")]#[test]fn every_call_is_a_profiler_span_timed_by_the_c_api() {+ let _cpp = route::on_cpp();solidcraft_profile::set_enabled(true);let mark = solidcraft_profile::mark();- let b = Brep::make_box([0.0; 3], [1.0; 3]).unwrap();+ // the C API's own box, whichever kernel is in force+ crate::init().unwrap();+ let b = ffi::make_box(&[0.0; 3], &[1.0; 3]).map(Brep::made).unwrap();let _ = b.volume(1e-7).unwrap();let r = mark.report();let names: Vec<&str> = r.rows.iter().filter(|r| r.category == "smlib").map(|r| r.name).collect();diff --git a/crates/smlib/src/trim.rs b/crates/smlib/src/trim.rsindex 4c9948d967..a528e22324 100644--- a/crates/smlib/src/trim.rs+++ b/crates/smlib/src/trim.rs@@ -1,7 +1,7 @@//! Untrim and extend of a sheet's faces. Each returns a new body and leaves its input unchanged;//! faces and holes are chosen by points, as [`crate::ops`] chooses them.-use crate::{Brep, Result, error, ffi, init};+use crate::{Brep, Result, core, error, ffi, init, route};/// How [`Brep::extend_sheet`] continues a surface past its side.#[derive(Clone, Copy, Debug, PartialEq, Eq)]@@ -29,12 +29,15 @@ impl Brep {/// all the way round closes on the surface's seam). The face alone, or/// with `in_place` the whole body with it replaced. Tags follow the face and its edges.pub fn untrim_face(&self, point: [f64; 3], tolerance: f64, holes: Holes, outer: bool, in_place: bool) -> Result<Brep> {- init()?;let holes = match holes {Holes::All => None,Holes::At(at) => Some(at),};- ffi::trim::untrim_face(&self.0, &point, tolerance, holes, outer, in_place).map(Brep).map_err(|s| match s {+ if route::backend() == route::Backend::Solidcore {+ return core::trim::untrim_face(self.core()?, point, tolerance, holes, outer, in_place).map(Brep::made_core);+ }+ init()?;+ ffi::trim::untrim_face(self.cpp()?, &point, tolerance, holes, outer, in_place).map(Brep::made).map_err(|s| match s {ffi::ops::ERR_PICK_NONE => crate::Error::NoMatch { point: 0 },s => error(s),})@@ -45,13 +48,16 @@ impl Brep {/// `how` says: SMLib's extended surface over the grown box, the face and its sides carrying/// the tags of those they continue. A sheet of another shape is [`crate::Error::Unsupported`].pub fn extend_sheet(&self, point: [f64; 3], tolerance: f64, distance: f64, how: Continuation) -> Result<Brep> {+ if route::backend() == route::Backend::Solidcore {+ return core::trim::extend_sheet(self.core()?, point, tolerance, distance, how).map(Brep::made_core);+ }init()?;let mode = match how {Continuation::Natural => ffi::trim::EXTEND_NATURAL,Continuation::Tangent => ffi::trim::EXTEND_TANGENT,Continuation::Curvature => ffi::trim::EXTEND_CURVATURE,};- ffi::trim::extend_sheet(&self.0, &point, tolerance, distance, mode).map(Brep).map_err(|s| match s {+ ffi::trim::extend_sheet(self.cpp()?, &point, tolerance, distance, mode).map(Brep::made).map_err(|s| match s {ffi::ops::ERR_PICK_NONE => crate::Error::NoMatch { point: 0 },s => error(s),})@@ -60,8 +66,11 @@ impl Brep {/// A point inside each face, in SMLib's face order: on the face's surface, inside its trims/// (`SmFace::CalculateAnInternalPoint`).pub fn face_points(&self) -> Result<Vec<[f64; 3]>> {+ if route::backend() == route::Backend::Solidcore {+ return core::trim::face_points(self.core()?);+ }init()?;let [faces, _, _] = self.counts()?;- ffi::trim::face_points(&self.0, faces).map_err(error)+ ffi::trim::face_points(self.cpp()?, faces).map_err(error)}}diff --git a/crates/smlib/tests/ssi_corpus.rs b/crates/smlib/tests/ssi_corpus.rsindex d75ce76ae9..c2b33b287a 100644--- a/crates/smlib/tests/ssi_corpus.rs+++ b/crates/smlib/tests/ssi_corpus.rs@@ -367,7 +367,6 @@ fn parity_with_python_scorer() {/// The cases SMLib's GlobalSurfaceIntersect passes at approximation tolerance 1e-6, as score.py/// grades the corpus runner's output. A fix that makes another case pass adds it here.-#[cfg(feature = "native")]const GSI_1E6_PASS: &[&str] = &["c1_cone_plane_ellipse","c1_cone_plane_hyperbola",@@ -483,10 +482,8 @@ const GSI_1E6_PASS: &[&str] = &[];/// The corpus runner's samples per curve.-#[cfg(feature = "native")]const RUNNER_SAMPLES: usize = 4001;-#[cfg(feature = "native")]fn surface(s: &Value) -> Result<solidcraft_smlib::ssi::Surface, String> {use solidcraft_smlib::ssi::Surface;let f = |k: &str| s.get(k).map(ssi_score::geom::num).ok_or(format!("{k}: missing"));@@ -535,7 +532,6 @@ fn surface(s: &Value) -> Result<solidcraft_smlib::ssi::Surface, String> {/// interval, each UV curve over its own, the surfaces at the UV samples), samples that cannot be/// evaluated dropped, empty UV arrays for a UV curve the method did not return, the runner's type/// names, and no isolated points (the runner only reports those in face mode).-#[cfg(feature = "native")]fn runner_output(r: solidcraft_smlib::Result<solidcraft_smlib::ssi::SsiResult>,a: &solidcraft_smlib::ssi::Surface,@@ -581,25 +577,40 @@ fn runner_output(Outcome::Ran(EngineResult { status: ssi_score::SM_SUCCESS, status_name: None, time_ms: ms, curves, points: Vec::new() })}-/// Every case through SMLib's GlobalSurfaceIntersect at approximation tolerance 1e-6, scored as-/// score.py scores the corpus runner's `gsi 1e-6` run: exactly [`GSI_1E6_PASS`] pass.-#[cfg(feature = "native")]-#[test]-fn smlib_global_intersect_at_1e_6() {+/// One kernel at a time: the choice of kernel is process-wide.+static KERNEL_TESTS: std::sync::Mutex<()> = std::sync::Mutex::new(());++/// Every case through `backend`'s GlobalSurfaceIntersect at approximation tolerance 1e-6, scored as+/// score.py scores the corpus runner's `gsi 1e-6` run. Prints each case that does not pass.+/// `None` when `SOLIDCRAFT_KERNEL` chose the other kernel: it wins over `set_choice`, and scoring+/// the wrong kernel against this one's list says nothing.+fn global_intersect_scores(backend: solidcraft_smlib::route::Backend) -> Option<Vec<Score>> {+ use solidcraft_smlib::route::{Backend, choice, set_choice};use solidcraft_smlib::ssi::{Method, intersect};let t0 = std::time::Instant::now();let cases = all_cases();- // SMLib serialises its calls, so the cases run one after another; only the scoring is parallel.- let outcomes: Vec<Outcome> = cases- .iter()- .map(|case| {- let a = surface(&case.surfaces[0]).unwrap_or_else(|e| panic!("{} surface 1: {e}", case.id));- let b = surface(&case.surfaces[1]).unwrap_or_else(|e| panic!("{} surface 2: {e}", case.id));- let t = std::time::Instant::now();- let r = intersect(&a, &b, Method::Global, 1e-6);- runner_output(r, &a, &b, t.elapsed().as_secs_f64() * 1e3)- })- .collect();+ let outcomes: Vec<Outcome> = {+ let _kernel = KERNEL_TESTS.lock().unwrap_or_else(std::sync::PoisonError::into_inner);+ set_choice(backend);+ if choice() != backend {+ set_choice(Backend::Solidcore);+ eprintln!("skipped: SOLIDCRAFT_KERNEL chose the other kernel");+ return None;+ }+ // The kernels serialise their calls, so the cases run one after another; only the scoring is parallel.+ let outcomes = cases+ .iter()+ .map(|case| {+ let a = surface(&case.surfaces[0]).unwrap_or_else(|e| panic!("{} surface 1: {e}", case.id));+ let b = surface(&case.surfaces[1]).unwrap_or_else(|e| panic!("{} surface 2: {e}", case.id));+ let t = std::time::Instant::now();+ let r = intersect(&a, &b, Method::Global, 1e-6);+ runner_output(r, &a, &b, t.elapsed().as_secs_f64() * 1e3)+ })+ .collect();+ set_choice(Backend::Solidcore);+ outcomes+ };let ran = t0.elapsed();// Status names for the flags, from the SMLib sources the build used, as score.py has them.let manifest = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));@@ -626,7 +637,7 @@ fn smlib_global_intersect_at_1e_6() {by_verdict.entry(s.verdict).or_default().push(&s.id);}println!(- "SMLib GlobalSurfaceIntersect, approx tol 1e-6 ({} cases, SMLib {:.1} s, total {:.1} s)",+ "{backend:?} GlobalSurfaceIntersect, approx tol 1e-6 ({} cases, kernel {:.1} s, total {:.1} s)",scores.len(),ran.as_secs_f64(),t0.elapsed().as_secs_f64()@@ -637,7 +648,14 @@ fn smlib_global_intersect_at_1e_6() {for s in scores.iter().filter(|s| s.verdict != Verdict::Pass) {println!(" {:<40} {:<15} {}", s.id, s.verdict.as_str(), s.flags.join("; "));}+ Some(scores)+}+/// Exactly [`GSI_1E6_PASS`] pass on the C++ kernel.+#[cfg(feature = "native")]+#[test]+fn smlib_global_intersect_at_1e_6() {+ let Some(scores) = global_intersect_scores(solidcraft_smlib::route::Backend::Smlib) else { return };let passed: std::collections::BTreeSet<&str> = scores.iter().filter(|s| s.verdict == Verdict::Pass).map(|s| s.id.as_str()).collect();let listed: std::collections::BTreeSet<&str> = GSI_1E6_PASS.iter().copied().collect();assert_eq!(listed.len(), GSI_1E6_PASS.len(), "GSI_1E6_PASS lists a case twice");@@ -646,3 +664,16 @@ fn smlib_global_intersect_at_1e_6() {assert!(newly.is_empty() && lost.is_empty(), "now pass (add to GSI_1E6_PASS): {newly:?}; no longer pass: {lost:?}");assert_eq!(passed.len(), 111);}++/// solidcore passes every case the C++ kernel passes ([`GSI_1E6_PASS`]). The self-crossing+/// curves it missed (Viviani's figure eight, the crossing loops) are split at their crossings+/// since solidcore's `ssi_split_curves_at_singular_points` (tangency-labs/solidcore#2110).+#[test]+fn solidcore_global_intersect_at_1e_6() {+ let Some(scores) = global_intersect_scores(solidcraft_smlib::route::Backend::Solidcore) else { return };+ let passed: std::collections::BTreeSet<&str> = scores.iter().filter(|s| s.verdict == Verdict::Pass).map(|s| s.id.as_str()).collect();+ let listed: std::collections::BTreeSet<&str> = GSI_1E6_PASS.iter().copied().collect();+ let lost: Vec<&str> = listed.difference(&passed).copied().collect();+ let extra: Vec<_> = passed.difference(&listed).collect();+ assert!(lost.is_empty(), "solidcore misses what the C++ kernel passes: {lost:?}; extra passes: {extra:?}");+}diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rsindex d8ad6d998d..4d02a68872 100644--- a/crates/ui-egui/src/prefs.rs+++ b/crates/ui-egui/src/prefs.rs@@ -37,6 +37,8 @@ use crate::ui_kit;use crate::viewport::NavMode;pub const UNITS: &[&str] = &["mm", "cm", "m", "in", "ft"];+/// The Geometry kernel preference's choices, as `diagnostics.kernel` spells them.+pub const KERNELS: [&str; 2] = ["solidcore", "smlib"];pub const OPENSCAD_NAV: &str = "openscad";pub const TOUCHPAD_NAV: &str = "touchpad";/// A mouse button that can drag the camera.@@ -1159,6 +1161,11 @@ preference_settings! {/// Up/Down and the wheel over a focused value field step its plain number (`value_step`,/// #2320). Off by default: the keys move the text cursor and the wheel scrolls, as before.step_values: bool = false, PAGE_DESIGN => check_id("ui.step_values");+ /// Which geometry kernel answers every operation (one of [`KERNELS`]): `solidcore`, the+ /// default, or `smlib`, the C++ kernel. A saved `routed`, the old default, reads as+ /// `solidcore` ([`migrate`]). Applied through+ /// `diagnostics.kernel`; `SOLIDCRAFT_KERNEL`, when set, wins.+ geometry_kernel: String = "solidcore".into(), PAGE_DESIGN;/// When SMLib's full check runs while features are computed (`diagnostics.validation`):/// `each_feature` (the default) checks the bodies each feature keeps once; `each_step`, as/// before, checks after every sweep, boolean and blend; `off` (experimental) never does.@@ -1626,6 +1633,14 @@ pub struct PrefsWindow {/// The Profile operations preference the profiler last followed: applied when it changes,/// so `diagnostics.profile` (an agent) and SOLIDCRAFT_PROFILE can switch it in between.applied_profile: Option<bool>,+ /// The Geometry kernel preference `diagnostics.kernel` last applied: applied when it changes+ /// (and at startup), so an agent's `diagnostics.kernel` in between stands.+ applied_kernel: Option<String>,+ /// The choice `SOLIDCRAFT_KERNEL` forces when it overrides the preference (the command's+ /// `environment` and `choice`).+ pub(crate) kernel_environment: Option<String>,+ /// The saved kernel is one this build doesn't have (`smlib` without the C++ kernel): the page says so.+ pub(crate) kernel_unavailable: bool,/// The appearance last asked of the native window ([`sync_window_theme`]).window_theme: Option<egui::SystemTheme>,/// The perspective angle the view was last drawn with ([`follow_view_fov`]); 0 before the first.@@ -2298,6 +2313,26 @@ pub fn apply(app: &mut SolveApp, ctx: &egui::Context) {}app.prefs_window.applied_profile = Some(profile);}+ // The geometry kernel, through its command (an unknown saved value is the default). `smlib` on+ // a build without it is refused: the preference page and the status line say so.+ let kernel = KERNELS.iter().copied().find(|k| *k == app.preferences.geometry_kernel).unwrap_or(KERNELS[0]);+ if app.prefs_window.applied_kernel.as_deref() != Some(kernel) {+ match app.session.execute("diagnostics.kernel", &json!({ "choice": kernel })) {+ Ok(v) => {+ let environment = v.get("environment").and_then(serde_json::Value::as_bool).unwrap_or(false);+ app.prefs_window.kernel_environment =+ environment.then(|| v.get("choice").and_then(serde_json::Value::as_str).unwrap_or_default().to_string());+ app.prefs_window.kernel_unavailable = false;+ }+ Err(e) => {+ log::warn!("geometry kernel preference `{kernel}`: {e}");+ app.prefs_window.kernel_unavailable = true;+ let message = app.tr("prefs.geometry_kernel_unavailable").to_string();+ app.set_status(message, true);+ }+ }+ app.prefs_window.applied_kernel = Some(kernel.into());+ }apply_file_limits(&app.preferences);// The viewport's display quality (an unknown saved value draws at Normal).solidcraft_engine::doc::display_quality::set_current(@@ -4022,6 +4057,10 @@ pub fn migrate(mut p: Prefs) -> Prefs {p.orbit_around = OrbitAround::Cursor;p.orbit_cursor = false;}+ // `routed`, the old default, ran every operation on solidcore.+ if p.geometry_kernel == "routed" {+ p.geometry_kernel = KERNELS[0].into();+ }if !crate::space_mouse::drives_each_once(p.space_mouse_axis_source) {log::warn!("preferences: the 3D mouse axis assignment {:?} doesn't drive each axis once; using the default", p.space_mouse_axis_source);p.space_mouse_axis_source = crate::space_mouse::SAME_AXES;@@ -4162,6 +4201,10 @@ fn prepare_preferences({return Err("`validation` must be each_step, each_feature or off".into());}+ // Before `migrate`, which reads the old saved `routed` as the default: asked for now, it is refused.+ if p.get("geometry_kernel").is_some_and(|v| !v.as_str().is_some_and(|k| KERNELS.contains(&k))) {+ return Err(format!("`geometry_kernel` must be one of {}", KERNELS.join(", ")));+ }if let Some(value) = p.get("navigation_bar") {crate::navigation_bar::validate(value)?;}@@ -4185,6 +4228,9 @@ fn prepare_preferences(if !UNITS.contains(&new.default_units.as_str()) {return Err(format!("units must be one of {}", UNITS.join(", ")));}+ if !KERNELS.contains(&new.geometry_kernel.as_str()) {+ return Err(format!("`geometry_kernel` must be one of {}", KERNELS.join(", ")));+ }if !WINDOW_SYSTEMS.contains(&new.window_system.as_str()) {return Err(format!("`window_system` must be one of {}", WINDOW_SYSTEMS.join(", ")));}@@ -4362,6 +4408,61 @@ mod tests {assert!(!solidcraft_engine::profile::enabled());}+ /// The Geometry kernel preference reaches the kernel through diagnostics.kernel, at startup+ /// and when it changes, and only a choice the command knows is accepted. `smlib` keeps the C+++ /// kernel reachable, the behaviour from before solidcore was the default. (The kernel choice is+ /// process-wide and other tests start harnesses meanwhile, so `smlib` is only set on a build+ /// without it, where it is refused and nothing moves.)+ #[test]+ fn the_geometry_kernel_preference_applies_through_its_command() {+ use serde_json::json;+ let mut h = crate::scenario::Harness::new();+ h.frames(1);+ assert_eq!(h.app.prefs_window.applied_kernel.as_deref(), Some("solidcore"), "applied at startup");+ let r = h.app.session.execute("diagnostics.kernel", &json!({})).unwrap();+ let environment = (r["environment"] == json!(true)).then(|| r["choice"].as_str().unwrap_or_default().to_string());+ assert_eq!(h.app.prefs_window.kernel_environment, environment);+ assert!(h.call("ui.prefs", json!({"geometry_kernel": "truck"}))["error"].as_str().is_some_and(|e| e.contains("geometry_kernel")));+ // `routed` is gone: a saved one reads as solidcore (below), asked for now it is refused.+ assert!(h.call("ui.prefs", json!({"geometry_kernel": "routed"}))["error"].as_str().is_some_and(|e| e.contains("geometry_kernel")));+ assert_eq!(h.app.preferences.geometry_kernel, "solidcore");+ assert_eq!(super::KERNELS, ["solidcore", "smlib"]);+ h.call("ui.prefs", json!({"geometry_kernel": "solidcore"}));+ h.frames(2);+ assert_eq!(h.app.prefs_window.applied_kernel.as_deref(), Some("solidcore"));+ assert!(!h.app.prefs_window.kernel_unavailable);+ // Saved with the other preferences.+ let saved = serde_json::to_value(&h.app.preferences).unwrap();+ assert_eq!(saved["geometry_kernel"], json!("solidcore"));+ // On a build without the C++ kernel, asking for it says so: not a switch to the other one.+ if !solidcraft_engine::kernel::smlib_built() {+ h.call("ui.prefs", json!({"geometry_kernel": "smlib"}));+ h.frames(2);+ assert!(h.app.prefs_window.kernel_unavailable);+ assert_eq!(h.app.preferences.geometry_kernel, "smlib");+ assert_ne!(h.app.session.execute("diagnostics.kernel", &json!({})).unwrap()["choice"], json!("smlib"));+ h.call("ui.prefs", json!({"geometry_kernel": "solidcore"}));+ h.frames(2);+ assert!(!h.app.prefs_window.kernel_unavailable);+ }+ }++ /// A saved `routed`, the old default, loads as `solidcore`, without an error; any other value+ /// this version doesn't know stays as it was saved and runs on the default, and nothing panics.+ #[test]+ fn a_saved_routed_kernel_loads_as_solidcore() {+ use serde_json::json;+ let read = |saved: serde_json::Value| super::migrate(serde_json::from_value::<super::Prefs>(saved).unwrap()).geometry_kernel;+ assert_eq!(read(json!({"geometry_kernel": "routed"})), "solidcore");+ assert_eq!(read(json!({})), "solidcore");+ assert_eq!(read(json!({"geometry_kernel": "smlib"})), "smlib");+ assert_eq!(read(json!({"geometry_kernel": "truck"})), "truck");+ let mut h = crate::scenario::Harness::new();+ h.app.preferences.geometry_kernel = "truck".into();+ h.frames(2);+ assert_eq!(h.app.prefs_window.applied_kernel.as_deref(), Some("solidcore"));+ }+/// Preferences saved with a setting this version no longer has still load, every other/// setting kept: the removed key is ignored like any unknown one.#[test]diff --git a/crates/ui-egui/src/prefs/design.rs b/crates/ui-egui/src/prefs/design.rsindex b2c3424264..8fb59fe936 100644--- a/crates/ui-egui/src/prefs/design.rs+++ b/crates/ui-egui/src/prefs/design.rs@@ -136,4 +136,28 @@ fn origin_plane_names(app: &mut SolveApp, ui: &mut egui::Ui) {setting::hide_origin(app, ui);ui_kit::text(ui, app.tr("ui.hide_origin_note"), ui_kit::Text::Hint("hide_origin"));});+ // Which geometry kernel answers; `prefs::apply` applies it through diagnostics.kernel.+ ui_kit::settings_section(ui, "geometry_kernel", app.tr("prefs.geometry_kernel"), |ui| {+ // Under SOLIDCRAFT_KERNEL the control shows the environment's choice, disabled.+ let environment = app.prefs_window.kernel_environment.clone();+ ui.add_enabled_ui(environment.is_none(), |ui| {+ let options = ["solidcore", "SMLib"];+ let shown = environment.as_deref().unwrap_or(&app.preferences.geometry_kernel);+ let mut selected = KERNELS.iter().position(|k| *k == shown).unwrap_or(0);+ ui_kit::segmented(ui, &mut selected, &options, ui_kit::Segments { intrinsic: true, ..Default::default() });+ if let Some(kernel) = KERNELS.get(selected)+ && environment.is_none()+ && app.preferences.geometry_kernel != *kernel+ {+ app.preferences.geometry_kernel = (*kernel).into();+ }+ });+ ui_kit::text(ui, app.tr("prefs.geometry_kernel_note"), ui_kit::Text::Hint("geometry_kernel"));+ if environment.is_some() {+ ui_kit::text(ui, app.tr("prefs.geometry_kernel_environment"), ui_kit::Text::Hint("geometry_kernel_environment"));+ }+ if app.prefs_window.kernel_unavailable {+ ui_kit::text(ui, app.tr("prefs.geometry_kernel_unavailable"), ui_kit::Text::Hint("geometry_kernel_unavailable"));+ }+ });}diff --git a/deny.toml b/deny.tomlindex c24dbb4c7f..6769a37209 100644--- a/deny.toml+++ b/deny.toml@@ -13,3 +13,5 @@ allow-wildcard-paths = trueunknown-registry = "deny"unknown-git = "deny"allow-registry = ["https://github.com/rust-lang/crates.io-index"]+# solidcore, pinned by rev in Cargo.toml (crates/smlib's second backend).+allow-git = ["https://github.com/tangency-labs/solidcore"]diff --git a/docs/design-container.md b/docs/design-container.mdindex 36cb8324f1..2621663a90 100644--- a/docs/design-container.md+++ b/docs/design-container.md@@ -164,12 +164,12 @@ same triangles, colour and paint; the picture shown while opening draws its tria`cache/model.json` records `solidcraft-model-cache/8`, the producer revision`solidcraft-truck-adapter/4`, the application version, the build (source commit,CPU architecture and OS), the evaluation source (below, with the CPU architecture-and OS), the SHA-256 of the exact `document.json` (whose blob references pin every+and OS), the geometry kernel that computed it (`solidcore` or `smlib`), the SHA-256 of the exact `document.json` (whose blob references pin everySTEP, mesh and image payload) and of `cache/bodies.bin`, the slices, each kernelbody's slice and display share, and the model's records. A cache is read back only-when the format, the producer, the evaluation source, the platform and both+when the format, the producer, the evaluation source, the platform, the kernel and bothdigests match: the same source compiled for the same platform computes the same-numbers. The application version and the commit are recorded, not compared.+numbers on the same kernel; a design opened on the other kernel is evaluated on it. The application version and the commit are recorded, not compared.The evaluation source (`SOLIDCRAFT_EVALUATION_SOURCE`, `crates/io/build.rs`) is adigest of the committed source a model is computed from: the `doc` crate and everydiff --git a/docs/perf.md b/docs/perf.mdindex 69e32bbfc8..2e7c9daf95 100644--- a/docs/perf.md+++ b/docs/perf.md@@ -9,7 +9,8 @@ What it records, as nested spans on each thread:| Category | Spans ||---|---|-| `smlib` | every SMLib C API call, timed by the C API itself (`steady_clock`) |+| `solidcore` | every call into solidcore, the default kernel |+| `smlib` | every SMLib C API call, timed by the C API itself (`steady_clock`), when the C++ kernel is asked for || `kernel` | booleans, blends, sweeps, lofts, shell/draft/offset, healing, sewing, conversions, meshing, measuring || `import` | the stages of a STEP or IGES import: parse, index, each solid, placement, mesh check, convert batches || `feature` | each feature computed, by its type; `doc evaluate` around them |diff --git a/scripts/ci/test_kernel_rig_plan.py b/scripts/ci/test_kernel_rig_plan.pyindex 1c3bc1a679..eac3acee2b 100644--- a/scripts/ci/test_kernel_rig_plan.py+++ b/scripts/ci/test_kernel_rig_plan.py@@ -118,6 +118,7 @@ class Real(unittest.TestCase):for area, globs in {"PATHS-ALL": shared, **areas}.items():if area != "PATHS-ALL":self.assertTrue(os.path.isfile(os.path.join(ROOT, plan.CASES, area, "KNOWN_FAILING")), area)+ self.assertTrue(os.path.isfile(os.path.join(ROOT, plan.CASES, area, "KNOWN_FAILING.solidcore")), area)for g in globs:with self.subTest(area=area, glob=g):rx = plan.glob_regex(g)diff --git a/tests/KNOWN_FAILING_TESTS b/tests/KNOWN_FAILING_TESTSindex 6f482f295f..a197970b2d 100644--- a/tests/KNOWN_FAILING_TESTS+++ b/tests/KNOWN_FAILING_TESTS@@ -1,43 +1,42 @@-# The cargo tests that fail today, one a line: `<test> <why it fails today>`, with the issue that-# tracks it when there is one. Sorted. `<test>` is nextest's `<binary id>::<test name>`, as the-# junit report names it. CI's test jobs (`cargo xtask known-failing`) fail on a test that fails-# and is not listed here, and on a listed test that passes: a fix removes its line in the same-# pull request. The tests stay un-ignored, so every run shows whether they still fail.-# Refresh (after an SMLib pin bump): download the junit artifacts of develop's latest CI run, one-# directory each (`gh run download <run> -R tangency-labs/solidcraft -n <artifact> -D <dir>/<artifact>`-# for junit and junit-gpu-1..4), run `cargo xtask known-failing --junit <dir>`, then drop each-# FIXED line and add each REGRESSION line with its cause, from the test's failure message.-# Baseline: develop 2bf58241f (CI run 41522001173, x86_64 Linux), after the SMLib a18bbe5 pin (v1.1.0-alpha).-solidcraft-cli::action_matrix::action_matrix_sample 2 baseline actions fail on SMLib: 2 shells (Bad Loop Orient on issue-616-lid-ribs; status 1001 on filleted-shelled-box, shelled again open at an inner wall)-solidcraft-cli::naming_corpus::corpus_designs_name_alike_every_build_and_fail_where_a_reference_is_gone oracle/83-boundary-loop-thicken does not load: step 8, SMLib thicken status 1001-solidcraft-doc::eval::chain_tests::a_propagated_chain_that_cannot_build_says_how_to_blend_the_edge_alone the propagated chain now builds a round (9 faces), so there is no refusal to read, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established-solidcraft-doc::eval::cost_tests::a_tap_marking_searches_only_the_bodies_near_it main's mesh-based tap-marking cull (#10303, beyond_cylinder_reach) not taken; the exact replacement is to come-solidcraft-doc::eval::cost_tests::a_tap_marking_still_searches_the_bodies_within_its_reach main's mesh-based tap-marking cull (#10303, beyond_cylinder_reach) not taken; the exact replacement is to come-solidcraft-engine::cmd::file::tests::each_format_has_an_export_command_of_its_own SMLib meshes a box's planar faces into 124 triangles, not 12 (the STL is 6284 bytes, the test counts 84 + 50 x 12)-solidcraft-engine::cmd::sketch_project::tests::intersection_curve_of_picked_faces_spans_the_whole_surface main's mesh-based version (#9107) not taken; the exact replacement is to come+# The cargo tests that fail today on the default kernel, solidcore, one a line: `<test> <why it fails+# today>`, with the issue that tracks it when there is one. Sorted. `<test>` is nextest's+# `<binary id>::<test name>`, as the junit report names it. CI's test jobs (`cargo xtask known-failing`)+# fail on a test that fails and is not listed here, and on a listed test that passes: a fix removes its+# line in the same pull request. The tests stay un-ignored, so every run shows whether they still fail.+# `KNOWN_FAILING_TESTS.smlib` is the same list for the C++ kernel (SOLIDCRAFT_KERNEL=smlib, graded with+# --list). Refresh as that list's header says.+solidcraft-cli::action_matrix::action_matrix_sample 3 baseline actions fail, the same 3 as on C++: 2 shells (Bad Loop Orient on issue-616-lid-ribs; status 1001 on filleted-shelled-box), 1 fillet (SmSurfOfRevolution Test #7 on oblique_cut_of_cylinder)+solidcraft-cli::model_cache::a_later_round_after_opening_blends_the_saved_rounds_again the later r3 round at the r2 mitre builds solidcore's 10-face corner (7928.743041), the test wants SMLib f916a8d's setback corner (smlib#104), which solidcore ports in solidcore#2310: 15 faces, 7928.142563938+solidcraft-cli::naming_corpus::corpus_designs_name_alike_every_build_and_fail_where_a_reference_is_gone oracle/83-boundary-loop-thicken does not load: step 8, thicken status 1001, as on C+++solidcraft-doc::eval::cost_tests::a_tap_marking_searches_only_the_bodies_near_it main's mesh-based version (#10303) not taken; the exact replacement is to come+solidcraft-doc::eval::cost_tests::a_tap_marking_still_searches_the_bodies_within_its_reach main's mesh-based version (#10303) not taken; the exact replacement is to come+solidcraft-engine::cmd::edit::tests::inserting_variable_fillet_control_preserves_parameters_at_existing_positions solidcore refuses a variable fillet whose law has a corner (solidcore#430)+solidcraft-engine::cmd::file::tests::each_format_has_an_export_command_of_its_own the box's planar faces are meshed into 124 triangles, not 12 (the STL is 6284 bytes, the test counts 84 + 50 x 12), as on SMLib+solidcraft-engine::cmd::sketch_project::tests::intersection_curve_of_picked_faces_spans_the_whole_surface its premise fails off truck: the fit-point spline wall's 3 span faces are not one surface patch in the kernel's mesh (surface_patch gives 1 face, the test wants 3), as on SMLibsolidcraft-engine::extent_tests::cut_to_the_far_side_of_a_curved_wall main's mesh-based version (#8634) not taken; the exact replacement is to comesolidcraft-engine::face_name_tests::a_join_that_makes_the_body_bigger_leaves_round_walls_it_never_touched_alone main's edge lookup by a stored point (#11286) finds the edge on the display mesh (edge_near on the body's mesh), not taken; the exact replacement is to come-solidcraft-engine::hole_face_tests::a_hole_wider_than_the_part_says_it_removes_all_of_it a 40 mm hole at (10, 10) touches the plate's edge y = 30 at one point; SMLib parts the plate there into 2 bodies, the test wants truck's 1-solidcraft-engine::measure_centre_tests::a_fillet_round_a_boss_reports_its_radius SMLib's round at the foot of a boss is not an analytic torus of minor radius 3, so no face of the body is (the test finds none to measure)-solidcraft-engine::tests::fillet_fit_taper_closes_to_a_point SMLib fillet status 1001 on the taper fit (radius 16 closing to 0)-solidcraft-engine::tests::mirror_placed::dragging_a_mirrored_part_meshes_its_copies_once on SMLib a copy of a copy drawn from its first copy's triangles (#10101) is triangulated differently from a fresh evaluation; the surface is the same. Dealt with in solidcore, where the mesher moves (docs/layers.md)+solidcraft-engine::hole_face_tests::a_hole_wider_than_the_part_says_it_removes_all_of_it a 40 mm hole at (10, 10) touches the plate's edge y = 30 at one point; the kernel parts the plate there into 2 bodies, the test wants truck's 1, as on SMLib+solidcraft-engine::measure_centre_tests::a_fillet_round_a_boss_reports_its_radius the round at the foot of a boss is not an analytic torus of minor radius 3, so no face of the body is (the test finds none to measure), as on SMLib+solidcraft-engine::tests::a_later_round_at_a_mitred_corner_is_blended_with_the_rounds_there solidcore's corner of three rounds of different radii is 7928.74304145614 with 10 faces; the test wants SMLib f916a8d's setback corner (smlib#104), which solidcore ports in solidcore#2310: 15 faces, 7928.142563938+solidcraft-engine::tests::chord_and_variable_fillets its 2 → 4 → 2 waist: solidcore refuses a variable fillet whose law has a corner (solidcore#430)+solidcraft-engine::tests::fillet_fit_taper_closes_to_a_point fillet status 1001 on the taper fit (radius 16 closing to 0), as on C+++solidcraft-engine::tests::mirror_placed::dragging_a_mirrored_part_meshes_its_copies_once a copy of a copy drawn from its first copy's triangles (#10101) is triangulated differently from a fresh mesh of it, where truck's meshes are the same under a rigid move, as on SMLibsolidcraft-engine::tests::robustness::fillet_into_an_earlier_round R2 into the earlier round: volume 35923.387 against 35919.524, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established-solidcraft-kernel::blend::corner_tests::a_round_ending_in_an_earlier_round_matches_both_together SMLib fillet status 1001 on the round that ends in the earlier one-solidcraft-kernel::blend::corner_tests::corner_blends_hold_at_any_scale at 0.01x a picked edge runs on tangentially into an unblended edge and SMLib's result is not a closed solid (the smooth-vertex End, tangency-labs/smlib#81)-solidcraft-kernel::blend_corner::tests::a_round_next_to_a_round_of_another_radius the face count is 9, not the expected count, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established-solidcraft-kernel::blend_corner::tests::issue2422_vertical_after_separate_bottom_rounds SMLib's check refuses the fillet: edge and vertex tolerance 0.97 against the body's 0.01 (#2422)-solidcraft-kernel::blend_smlib::tests::smooth_edges_and_unfinished_tangent_chains_are_refused_saying_why the smooth edge builds (volume 7957.723) where a refusal is expected, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-kernel::blend::corner_tests::a_round_ending_in_an_earlier_round_matches_both_together fillet status 1001 on the round that ends in the earlier one, as on C+++solidcraft-kernel::blend::corner_tests::corner_blends_hold_at_any_scale at 0.01x the arc case's rounds remove 72.783 (scaled back) against 72.713 at 1x, as on C+++solidcraft-kernel::blend_corner::tests::issue2422_vertical_after_separate_bottom_rounds the check refuses the fillet: edge and vertex tolerance 0.97 against the body's 0.01, as on C++ (#2422)+solidcraft-kernel::blend_corner::tests::three_rounds_at_a_corner the corner's variable-radius transition between rounds of different radii meets its neighbours at 0.144 degrees once its sections are the balls' touch circles (fillet_gn_section_generator, solidcore#2262; 0 with the great circles), as on SMLib d01d7b0; the corner step replaces that transition+solidcraft-kernel::blend_variable::tests::variable_radius_with_a_corner_through_a_middle_point solidcore refuses a variable fillet whose law has a corner (solidcore#430)solidcraft-kernel::blend_wrong_way_tests::a_chamfer_that_would_grow_the_part_on_a_convex_edge_is_refused SMLib refuses the chamfer for another reason first: status 1001, the picked edge runs on tangentially into an unblended edge (tangent_chain is on)-solidcraft-kernel::corner_g2::tests::a_concave_corner_takes_the_g2_patch_too the concave G2 corner's curvature jump clear of the corners is 5.5e-2, above the bound, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established-solidcraft-kernel::corner_g2::tests::a_long_setback_keeps_the_g2_patch_inside_the_box at set backs 11 to 15 the G2 corner patch bulges 2.6e-6 to 1.33e-3 past the box (the explicit corner is in progress)-solidcraft-kernel::corner_g2::tests::curvature_rounds_meet_at_a_g2_corner the corner loop's fill misses its neighbours' curvature by 1.6e-3 (tolerance 1e-3), on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established-solidcraft-kernel::corner_g2::tests::set_back_8_the_g2_corner_lies_between_the_hull_and_the_prisms set back 8: the G2 corner's distance check reads 0.0611, past its bound (volume 47370.642, in range), on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established-solidcraft-kernel::corner_g2::tests::the_box_corner_g2_patch_is_a_closed_solid_curvature_continuous_to_its_neighbours the fitted G2 corner patch bulges 1.7e-5 past the box, which SMLib's exact tight box now sees (the explicit G2 corner builds it inside)-solidcraft-kernel::issue_851_tests::blend_the_arc_top_edge_and_the_top_front_edge removes 59.148 against 60.122, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established-solidcraft-kernel::issue_851_tests::fillet_the_arc_top_edge_and_the_front_upright_at_the_arc removes 31.497 against 32.310, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established-solidcraft-kernel::issue_851_tests::fillet_the_top_front_edge_and_the_front_left_upright removes 42.236 against 43.187, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established-solidcraft-kernel::issue_851_tests::fillet_the_top_front_edge_and_the_front_upright_at_the_arc removes 41.341 against 42.146, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established-solidcraft-kernel::smooth_edges::tests::a_seam_split_in_two_edges_is_drawn_whole the side seam is one edge ([24]), not split in two, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established-solidcraft-kernel::tests::fillet_tabbed_plate_outer_loop_and_partial_selection_after_hole the partial selection runs on tangentially into an unblended edge and SMLib's result is not a closed solid (the smooth-vertex End, tangency-labs/smlib#81)-solidcraft-smlib::ops::tests::a_setback_corner_left_open_returns_its_hole the open corner returns holes of 9, 27 and 19 edges, not its one hole; SMLib's open_holes counts a seam edge its own face uses twice as free (fixed for v1.1.0-alpha.1)-solidcraft-smlib::ops::tests::fillet_takes_exactly_the_picked_edges one round on the picked edge gives 9 faces, not the expected count, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-kernel::corner_g2::tests::a_long_setback_keeps_the_g2_patch_inside_the_box at set backs 11 to 15 the G2 corner patch bulges past the box, as on C+++solidcraft-kernel::corner_g2::tests::curvature_rounds_meet_at_a_g2_corner the corner between curvature rounds jumps 2.07 in curvature over 538 stations on solidcore; the test wants it curvature continuous, as SMLib f916a8d's setback corner (smlib#104), which solidcore ports in solidcore#2310 builds it+solidcraft-kernel::corner_g2::tests::the_box_corner_g2_patch_is_a_closed_solid_curvature_continuous_to_its_neighbours the fitted G2 corner patch bulges 1.7e-5 past the box, as on C+++solidcraft-kernel::fillet_setback_tests::a_setback_not_past_the_radius_is_refused_naming_the_least solidcore builds setback 5.5 (15 faces) where SMLib f916a8d's setback corner (smlib#104), which solidcore ports in solidcore#2310 refuses it naming the least that builds; solidcraft_smlib::blend_fit names no size on solidcore until then+solidcraft-kernel::tests::fillet_tabbed_plate_outer_loop_and_partial_selection_after_hole the R25 rim and a corner arc round together since solidcore#2223, but the two R2 corner arcs picked together fail 1001 in trim_at_creases (cliff_overflow with the crease trims off), though each builds alone (solidcore#2314)+solidcraft-smlib::core::blend_tests::fillet_all_edges::solidcore_matches_the_cpp_kernel the C++ comparison: solidcore's 8 box corners are analytic spheres, C++ 5e8c9c1's rational splines (SMLib 5e8c9c1's blend (Ball corners as rational patches, the round as its definition, smlib#79), which solidcore ports in solidcore#2273)+solidcraft-smlib::core::blend_tests::fillet_variable_linear::solidcore_matches_the_cpp_kernel the C++ comparison: solidcore 5972.141093 against C++ 5e8c9c1's 5972.142573 (SMLib 5e8c9c1's blend (Ball corners as rational patches, the round as its definition, smlib#79), which solidcore ports in solidcore#2273)+solidcraft-smlib::core::blend_tests::rounds_on_the_871_part the C++ comparison: solidcore 3874.348250 against C++ 5e8c9c1's 3874.348458 (SMLib 5e8c9c1's blend (Ball corners as rational patches, the round as its definition, smlib#79), which solidcore ports in solidcore#2273)+solidcraft-smlib::core::blend_tests::setback_corner::solidcore_matches_the_cpp_kernel the C++ comparison: solidcore 5943.191647 against C++ f916a8d's 5948.231174 (SMLib f916a8d's setback corner (smlib#104), which solidcore ports in solidcore#2310)+solidcraft-smlib::core::convert_tests::cpp_round_trip::a_shelled_rounded_box the C++ round trip: the shelled rounded box C++ 5e8c9c1 builds differs from solidcore's in its arrays (real array 154[0]: -10 against 0), its corners built by SMLib 5e8c9c1's blend (Ball corners as rational patches, the round as its definition, smlib#79), which solidcore ports in solidcore#2273+solidcraft-smlib::core::offset_tests::mitred_rounds_follow_a_moved_top the C++ comparison: solidcore's offset edges keep their tolerances (offset_edges_keep_source_tolerance, solidcore#2111), C++ at 7ac037e's do not, so the moved tops' volumes are 2e-9 to 2.3e-7 apart; both are 1.2e-8 to 3.1e-7 off the closed form at accuracy 1e-8, solidcore with the fix 2.1e-7 at most+solidcraft-smlib::ops::tests::a_variable_round_with_a_corner_in_its_law_is_its_balls_union solidcore refuses a variable fillet whose law has a corner (solidcore#430)diff --git a/tests/KNOWN_FAILING_TESTS.smlib b/tests/KNOWN_FAILING_TESTS.smlibnew file mode 100644index 0000000000..dfbef64d06--- /dev/null+++ b/tests/KNOWN_FAILING_TESTS.smlib@@ -0,0 +1,43 @@+# The cargo tests that fail today on the C++ kernel (SOLIDCRAFT_KERNEL=smlib), one a line: `<test> <why it fails today>`, with the issue that+# tracks it when there is one. Sorted. `<test>` is nextest's `<binary id>::<test name>`, as the+# junit report names it. CI's test jobs (`cargo xtask known-failing`) fail on a test that fails+# and is not listed here, and on a listed test that passes: a fix removes its line in the same+# pull request. The tests stay un-ignored, so every run shows whether they still fail.+# Refresh (after an SMLib pin bump): download the junit artifacts of develop's latest CI run, one+# directory each (`gh run download <run> -R tangency-labs/solidcraft -n <artifact> -D <dir>/<artifact>`+# for junit and junit-gpu-1..4), run `cargo xtask known-failing --junit <dir>`, then drop each+# FIXED line and add each REGRESSION line with its cause, from the test's failure message.+# Baseline: develop 38fd4a4f6 (CI run 41157648345, x86_64 Linux), after the SMLib eaa998a pin; SMLib lines as of f916a8d (smlib 5862ee223).+solidcraft-cli::action_matrix::action_matrix_sample 2 baseline actions fail on SMLib: 2 shells (Bad Loop Orient on issue-616-lid-ribs; status 1001 on filleted-shelled-box, shelled again open at an inner wall)+solidcraft-cli::naming_corpus::corpus_designs_name_alike_every_build_and_fail_where_a_reference_is_gone oracle/83-boundary-loop-thicken does not load: step 8, SMLib thicken status 1001+solidcraft-doc::eval::chain_tests::a_propagated_chain_that_cannot_build_says_how_to_blend_the_edge_alone the propagated chain now builds a round (9 faces), so there is no refusal to read, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-doc::eval::cost_tests::a_cut_leaves_bodies_it_cannot_reach_as_they_were main's mesh-based version (#10303) not taken; the exact replacement is to come+solidcraft-doc::eval::cost_tests::a_tap_marking_searches_only_the_bodies_near_it main's mesh-based version (#10303) not taken; the exact replacement is to come+solidcraft-doc::eval::cost_tests::a_tap_marking_still_searches_the_bodies_within_its_reach main's mesh-based version (#10303) not taken; the exact replacement is to come+solidcraft-engine::cmd::file::tests::each_format_has_an_export_command_of_its_own SMLib meshes a box's planar faces into 124 triangles, not 12 (the STL is 6284 bytes, the test counts 84 + 50 x 12)+solidcraft-engine::cmd::sketch_project::tests::intersection_curve_of_picked_faces_spans_the_whole_surface main's mesh-based version (#9107) not taken; the exact replacement is to come+solidcraft-engine::extent_tests::cut_to_the_far_side_of_a_curved_wall main's mesh-based version (#8634) not taken; the exact replacement is to come+solidcraft-engine::hole_face_tests::a_hole_wider_than_the_part_says_it_removes_all_of_it a 40 mm hole at (10, 10) touches the plate's edge y = 30 at one point; SMLib parts the plate there into 2 bodies, the test wants truck's 1+solidcraft-engine::measure_centre_tests::a_fillet_round_a_boss_reports_its_radius SMLib's round at the foot of a boss is not an analytic torus of minor radius 3, so no face of the body is (the test finds none to measure)+solidcraft-engine::tests::fillet_fit_taper_closes_to_a_point SMLib fillet status 1001 on the taper fit (radius 16 closing to 0)+solidcraft-engine::tests::mirror_placed::dragging_a_mirrored_part_meshes_its_copies_once on SMLib a copy of a copy drawn from its first copy's triangles (#10101) is triangulated differently from a fresh evaluation; the surface is the same. Dealt with in solidcore, where the mesher moves (docs/layers.md)+solidcraft-engine::tests::robustness::fillet_into_an_earlier_round R2 into the earlier round: volume 35923.387 against 35919.524, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-engine::tests::shell_tangent_chain_that_opens_every_face_explains_how_to_keep_walls SMLib shell status 1034 on a box with all 12 edges rounded (Ball corners since 5e8c9c1), opened at one face (tangency-labs/smlib#102)+solidcraft-kernel::blend::corner_tests::a_round_ending_in_an_earlier_round_matches_both_together SMLib fillet status 1001 on the round that ends in the earlier one+solidcraft-kernel::blend::corner_tests::corner_blends_hold_at_any_scale at 0.01x a picked edge runs on tangentially into an unblended edge and SMLib's result is not a closed solid (the smooth-vertex End, tangency-labs/smlib#81)+solidcraft-kernel::blend_corner::tests::a_round_next_to_a_round_of_another_radius the face count is 9, not the expected count, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-kernel::blend_corner::tests::issue2422_vertical_after_separate_bottom_rounds SMLib's check refuses the fillet: edge and vertex tolerance 0.97 against the body's 0.01 (#2422)+solidcraft-kernel::blend_smlib::tests::smooth_edges_and_unfinished_tangent_chains_are_refused_saying_why the smooth edge builds (volume 7957.723) where a refusal is expected, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-kernel::corner_g2::tests::a_concave_corner_takes_the_g2_patch_too the concave G2 corner's curvature jump clear of the corners is 5.5e-2, above the bound, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-kernel::corner_g2::tests::a_long_setback_keeps_the_g2_patch_inside_the_box at set backs 11 to 15 the G2 corner patch bulges 2.6e-6 to 1.33e-3 past the box (the explicit corner is in progress)+solidcraft-kernel::corner_g2::tests::curvature_rounds_meet_at_a_g2_corner the corner loop's fill misses its neighbours' curvature by 1.6e-3 (tolerance 1e-3), on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-kernel::corner_g2::tests::set_back_8_the_g2_corner_lies_between_the_hull_and_the_prisms set back 8: the G2 corner's distance check reads 0.0611, past its bound (volume 47370.642, in range), on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-kernel::corner_g2::tests::the_box_corner_g2_patch_is_a_closed_solid_curvature_continuous_to_its_neighbours the fitted G2 corner patch bulges 1.7e-5 past the box, which SMLib's exact tight box now sees (the explicit G2 corner builds it inside)+solidcraft-kernel::issue_851_tests::blend_the_arc_top_edge_and_the_top_front_edge removes 59.148 against 60.122, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-kernel::issue_851_tests::fillet_the_arc_top_edge_and_the_front_upright_at_the_arc removes 31.497 against 32.310, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-kernel::issue_851_tests::fillet_the_top_front_edge_and_the_front_left_upright removes 42.236 against 43.187, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-kernel::issue_851_tests::fillet_the_top_front_edge_and_the_front_upright_at_the_arc removes 41.341 against 42.146, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-kernel::smooth_edges::tests::a_seam_split_in_two_edges_is_drawn_whole the side seam is one edge ([24]), not split in two, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being established+solidcraft-kernel::tests::fillet_tabbed_plate_outer_loop_and_partial_selection_after_hole the partial selection runs on tangentially into an unblended edge and SMLib's result is not a closed solid (the smooth-vertex End, tangency-labs/smlib#81)+solidcraft-smlib::ops::tests::a_setback_corner_left_open_returns_its_hole the open corner returns holes of 9, 27 and 19 edges, not its one hole; SMLib's open_holes counts a seam edge its own face uses twice as free (fixed for v1.1.0-alpha.1)+solidcraft-smlib::ops::tests::fillet_takes_exactly_the_picked_edges one round on the picked edge gives 9 faces, not the expected count, on SMLib v1.1.0-alpha (a18bbe5), passed on f916a8d; cause being establisheddiff --git a/tests/kernel-cases/README.md b/tests/kernel-cases/README.mdindex 3bae0e8fb9..517ed227cb 100644--- a/tests/kernel-cases/README.md+++ b/tests/kernel-cases/README.md@@ -1,17 +1,22 @@# Kernel regression rigEvery geometry case the old kernel (truck) got wrong, recorded in an issue, a pull request or a-crash report, is a use case here with its own right answer. The kernel, SMLib, is held to all of-them. `cargo xtask kernel-cases` runs them and writes [`docs/kernel-cases.md`](../../docs/kernel-cases.md).+crash report, is a use case here with its own right answer. The kernel, solidcore, is held to all+of them, as is the C++ SMLib kernel it was ported from when asked for. `cargo xtask kernel-cases`+runs them on solidcore; `--kernel smlib` runs them on C++ and writes+[`docs/kernel-cases.md`](../../docs/kernel-cases.md).```sh-cargo xtask kernel-cases # every case+cargo xtask kernel-cases # every case, on solidcorecargo xtask kernel-cases --cli target/release/solidcraft-cli --out /tmp/run # with a CLI already built-cargo run -p solidcraft-cli --features smlib -- kernel-cases tests/kernel-cases/booleans/<id> # one case+cargo xtask kernel-cases --kernel both --cli target/release/solidcraft-cli # SMLib and solidcore side by side+cargo run -p solidcraft-cli -- kernel-cases tests/kernel-cases/booleans/<id> # one case```-The CLI links SMLib by default (`scripts/fetch-smlib.sh` fetches the prebuilt library first);-built with `--no-default-features`, every operation answers that SMLib is not built. The run's output folder (`--out`, default `target/kernel-cases`)+The CLI builds with solidcore alone by default. The C++ SMLib kernel is opt-in at build time:+`--features smlib` links it (`scripts/fetch-smlib.sh` fetches the prebuilt library first), and+`--kernel smlib` or `both` without `--cli` builds the CLI that way. On a build without it, asking+for SMLib answers that this build doesn't include it. The run's output folder (`--out`, default `target/kernel-cases`)gets `results.json`, every case's full result, and `dumps/<area>-<case>/`: the inputs of eachSMLib call a case failed in, for replay (the CLI's `--dumps=DIR`, which the rig always passes).`--validation MODE` runs the cases' features under that mode of SMLib's check@@ -19,6 +24,13 @@ SMLib call a case failed in, for replay (the CLI's `--dumps=DIR`, which the rigonce), `each_step` (after every sweep, boolean and blend, as before) or `off`; the`KNOWN_FAILING` lists are each_feature's.+`--kernel solidcore|smlib|both` (default `solidcore`) picks the backend each case's process runs on,+through `SOLIDCRAFT_KERNEL`. A `solidcore` run keeps its `results.json`, `dumps/` and `report.md`+in `<out>/solidcore/` and leaves `docs/kernel-cases.md`, which is the `smlib` run's, alone. `both` runs every case on each+backend, keeps `docs/kernel-cases.md` as the SMLib report and writes the two side by side to+[`docs/kernel-cases-backends.md`](../../docs/kernel-cases-backends.md) (cases that differ first)+and `<out>/backends.json`.+## Rules- **The answer never comes from a kernel.** Not from truck's output, nor any commercial@@ -126,17 +138,19 @@ the frozen truck-geometry PRs, a `kernel-paused` PR), for the report's coverageEvery area is a regression suite: each case is one small case of one issue, with its exactanswer. `.github/workflows/kernel-rig.yml` runs them, and the ladder, on pull requests (notdrafts). A plan job (`scripts/ci/kernel_rig_plan.py`) picks the areas from the changed files, one-job builds `solidcraft-cli` (release, SMLib) and the rig's runner, and a matrix of shards, one per+job builds `solidcraft-cli` (release, `--features smlib`, for the ladder's `--kernel smlib`) and the rig's runner, and a matrix of shards, one perselected area plus the ladder, runs them in parallel; the `kernel-rig` check passes when everyselected shard does (and when none was selected). Pushes to main and develop, merge groups, therelease gate (`release-gate.yml`) and a run by hand run every area. Each area's shard runs:```shcargo xtask kernel-cases --area <area> --cli target/release/solidcraft-cli \- --known-failing tests/kernel-cases/<area>/KNOWN_FAILING+ --known-failing tests/kernel-cases/<area>/KNOWN_FAILING.solidcore```-`<area>/KNOWN_FAILING` lists the cases of that area that fail today, sorted, one a line with its+The gate grades the kernel the run is on, so a list is one kernel's: `<area>/KNOWN_FAILING.solidcore`+for the default, `<area>/KNOWN_FAILING` with `--kernel smlib` (`--kernel both` is refused). Each lists+the cases of that area that fail today on it, sorted, one a line with itscause (`<case> <why it fails today>`; `#` starts a comment; the header names the baseline: thedevelop commit and SMLib revision it was taken from). The gate fails on a **regression**, acase that fails (or crashes, hangs, or is not supported yet) and is not listed, and on a@@ -208,11 +222,15 @@ running part grows one tier at a time through `base`), so the last case carries`method` gives the derivation).```sh-cargo xtask kernel-cases --ladder --cli target/release/solidcraft-cli-cargo xtask kernel-cases --ladder --cli target/release/solidcraft-cli --gate-cargo xtask kernel-cases --ladder --cli target/release/solidcraft-cli --record "why"+cargo xtask kernel-cases --ladder --kernel smlib --cli target/release/solidcraft-cli+cargo xtask kernel-cases --ladder --kernel smlib --cli target/release/solidcraft-cli --gate+cargo xtask kernel-cases --ladder --kernel smlib --cli target/release/solidcraft-cli --record "why"```+The golden is the C++ kernel's, so these say `--kernel smlib`. Without it a run is on solidcore and is+graded against the same golden; today that differs on one case,+`ladder/09-shells-and-offsets/010-shell-under-rounded-top`.+The ladder needs no known-failing list: the golden is the reference. Its shard in the kernel riggate runs with `--gate`, which fails on any case whose status or counts differ from the golden,better or worse, and on a case with no golden; times are not compared there (they are thediff --git a/tests/kernel-cases/assemblies/KNOWN_FAILING.solidcore b/tests/kernel-cases/assemblies/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..088a09b0b6--- /dev/null+++ b/tests/kernel-cases/assemblies/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The assemblies cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/booleans/KNOWN_FAILING.solidcore b/tests/kernel-cases/booleans/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..862819c473--- /dev/null+++ b/tests/kernel-cases/booleans/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The booleans cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/construction/KNOWN_FAILING.solidcore b/tests/kernel-cases/construction/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..a84638c497--- /dev/null+++ b/tests/kernel-cases/construction/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The construction cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/continuity/KNOWN_FAILING.solidcore b/tests/kernel-cases/continuity/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..61ec46e21e--- /dev/null+++ b/tests/kernel-cases/continuity/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The continuity cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/crashes/KNOWN_FAILING.solidcore b/tests/kernel-cases/crashes/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..065f5bb4ef--- /dev/null+++ b/tests/kernel-cases/crashes/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The crashes cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/fillets/KNOWN_FAILING.solidcore b/tests/kernel-cases/fillets/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..9583fe6efe--- /dev/null+++ b/tests/kernel-cases/fillets/KNOWN_FAILING.solidcore@@ -0,0 +1,37 @@+# The fillets cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.+1080-fillet-equal-slope-basin-1-mm-rim-loop-4 [fail] continuity_order: got {'body': 'Slab', 'edges': 'blend', 'order': 'g0', want >= g1 at every blend seam+1080-fillet-sloped-basin-1-mm-rim-r4-2-edges [fail] continuity_order: got {'body': 'Slab', 'edges': 'blend', 'order': 'g0', want >= g1 at every blend seam+1080-fillet-sloped-basin-1-mm-rim-r4-4-edges [fail] continuity_order: got {'body': 'Slab', 'edges': 'blend', 'order': 'g0', want >= g1 at every blend seam+1207-fillet-bar-top-edge-after-boss-arc-round-r0-5 [fail] step 4 (solid.fillet): body `Arm`: the operation failed: SMLib fillet: SMLib's check refuses the result: 5 failed tests: SmBSplineCurve::Test #15 Bad Repeated CPts: BSplineCurve has Internal Coincident ControlPoints (causes+2893-chamfer-distance-and-angle-past-the-wall-refused [fail] refused, but not because "angle": step 2 (solid.chamfer): SMLib chamfer: operation: SMLib rejected the input (SM_ERR_INVALID_INPUT)+2893-chamfer-two-distances-elliptical-rim [fail] refused, but not because "not supported yet": step 3 (solid.chamfer): SMLib chamfer: operation: SMLib failed (status 1001) (tangent propagation blended the picked edges' tangent chain with them; with it off, tangent_chain:+4782-fillet-bar-edge-wider-than-both-faces [fail] continuity_order: got Box: no null seams want >= g1 at every blend seam+5158-fillet-round-just-past-a-10mm-face [fail] step 2 (solid.fillet): SMLib fillet: operation: SMLib failed (status 1001)+851-fillet-arc-then-top-front [fail] fillet status 1001, as on SMLib 5e8c9c1 (see KNOWN_FAILING): with tangent_chain true since 21f00a917 the top front edge's chain takes the arc round's end curve, where the R2 ball sits on that round's centre circle (a torus of tube-centre radius 0, the three-edge rolling-ball corner)+851-fillet-top-front-then-upright [fail] fillet status 1001, as on SMLib 5e8c9c1 (see KNOWN_FAILING): with tangent_chain true since 21f00a917 the upright's chain takes the first round's end curve, where the R2 ball sits on that round's axis (a torus of tube-centre radius 0, the three-edge rolling-ball corner)+9-fillet-corner-curvature-with-reduce-fit [unsupported] solid.fillet builds `corner: g2` with `fit: exact` only+9-fillet-corner-curvature-with-taper-fit [unsupported] solid.fillet builds `corner: g2` with `fit: exact` only+cov-fillet-g2-corner-beside-a-cylinder [fail] step 6 (solid.fillet): the open setback corner is not a closed solid, as on SMLib d01d7b0+cov-fillet-g2-five-edge-apex-corner [fail] step 12 (solid.fillet): invalid input: the setback must be more than 3.5056 mm at the corner (-0.000, 0.000, 30.000): the rounds' contact lines meet 3+cov-fillet-g2-four-edge-apex-corner [fail] step 11 (solid.fillet): invalid input: the setback must be more than 3.9027 mm at the corner (0.000, 0.000, 30.000): the rounds' contact lines meet 3.+cov-fillet-g2-mixed-corner [unsupported] refused as on SMLib d01d7b0: a G2 corner is set back only where every edge meeting it is rounded and all are convex or all concave+cov-fillet-g2-oblique-three-edge-corner [unsupported] refused on solidcore: its three edges meet at different wedge angles, and one curvature fillet takes the first edge's equal-area thumbweight for every edge (solidcore#2250, issuecomment-6563419897); SMLib d01d7b0 fails it too (see KNOWN_FAILING)+cov-fillet-g2-pocket-corner [fail] continuity_order: G1 at one seam where the corner patch meets a contact face (g2 wanted), as on SMLib d01d7b0 (see KNOWN_FAILING)+cov-fillet-section-curvature-pipe-on-plate-r2 [fail] solidcore builds the order-2 section as SMLib d01d7b0 did (40302.5908, G2 on both seams); the case now grades SMLib 5e8c9c1's section, the round as its definition, G3 on the pipe and 40307.8856 (fork 4a10ed8 and 79db628, to be ported in solidcore#2273)+cov-fillet-turn-swept-boss-base-r1 [fail] as on SMLib: solid.fillet has no `turn`; the corners are mitred (12508.9675, the Mitre case's volume)+cov-fillet-turn-swept-pocket-sharp-corner-refused-r1 [fail] as on SMLib: solid.fillet has no `turn`, so the sharp concave corners are mitred, not refused+cov-junction-boss-tilt-20-root-round [fail] fillet status 1001 on a cylinder tilted 20 degrees into the plate, as on SMLib+cov-junction-boss-tilt-40-root-round [fail] fillet status 1001 on a cylinder tilted 40 degrees into the plate, as on SMLib+cov-junction-tee-equal-round [fail] the result is not a closed solid, as on SMLib: equal pipes' intersection is two plane ellipses crossing, a corner the old corner code cannot join (the corner step)+cov-junction-y-junction-120-round [unsupported] refused as on SMLib: the faces between the three intersection curves narrow to nothing at the two triple points, so the room check trips (the corner step)+report-drafted-peg-front-and-concave-rounds-together-r2 [unsupported] step 13 (solid.fillet): invalid input: not supported yet: the fillet meets a corner of this kind, which SMLib's blends do not handle yet (where its ed+report-fillet-concave-arc-and-front-top-edge-together-r5-solver-residues [fail] bbox.min: got [0.4892940775280783, 0.05636444090890084, 0.0] want [0.4892940775280783, 0.05792545052986289, 0.0]+report-fillet-concave-arc-and-front-top-edge-together-r7-solver-residues [fail] bbox.min: got [0.4892940775169876, 0.02441657049978923, 0.0] want [0.4892940775280783, 0.05792545052986289, 0.0]+report-fillet-curvature-three-edges-at-bar-corner [fail] continuity_order: G1 at one seam where the corner patch meets a contact face (g2 wanted), as on SMLib d01d7b0 (see KNOWN_FAILING)+report-fillet-curvature-three-edges-at-bar-corner-solver-residues [fail] continuity_order: G1 at one seam where the corner patch meets a contact face (g2 wanted), as on SMLib d01d7b0 (see KNOWN_FAILING)+report-peg-front-and-concave-chamfers-together-d2 [fail] step 13 (solid.chamfer): SMLib chamfer: operation: SMLib failed (status 1001)+report-peg-front-and-concave-rounds-together-r2 [fail] continuity_order: got {'body': 'Peg', 'edges': 'blend', 'order': 'g0', ' want >= g1 at every blend seam+report-peg-front-and-concave-rounds-together-r5 [fail] continuity_order: got {'body': 'Peg', 'edges': 'blend', 'order': 'g0', ' want >= g1 at every blend seam+report-peg-step-front-and-concave-rounds-together-r2 [fail] continuity_order: got {'body': 'Peg', 'edges': 'blend', 'order': 'g0', ' want >= g1 at every blend seamdiff --git a/tests/kernel-cases/frames/KNOWN_FAILING.solidcore b/tests/kernel-cases/frames/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..ec1fb5489f--- /dev/null+++ b/tests/kernel-cases/frames/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The frames cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/history/KNOWN_FAILING.solidcore b/tests/kernel-cases/history/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..6fe1d5cf9c--- /dev/null+++ b/tests/kernel-cases/history/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The history cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/import/KNOWN_FAILING.solidcore b/tests/kernel-cases/import/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..1a5d014b90--- /dev/null+++ b/tests/kernel-cases/import/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The import cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/inspect/KNOWN_FAILING.solidcore b/tests/kernel-cases/inspect/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..54048005d1--- /dev/null+++ b/tests/kernel-cases/inspect/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The inspect cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/plastic/KNOWN_FAILING.solidcore b/tests/kernel-cases/plastic/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..5c65589d4c--- /dev/null+++ b/tests/kernel-cases/plastic/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The plastic cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/sheet-metal/KNOWN_FAILING.solidcore b/tests/kernel-cases/sheet-metal/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..ef474ce810--- /dev/null+++ b/tests/kernel-cases/sheet-metal/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The sheet-metal cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/shell/KNOWN_FAILING.solidcore b/tests/kernel-cases/shell/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..e768469d0c--- /dev/null+++ b/tests/kernel-cases/shell/KNOWN_FAILING.solidcore@@ -0,0 +1,4 @@+# The shell cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.+cov-shell-again-open-at-an-inner-wall-of-a-shelled-box [fail] step 9 (solid.shell): SMLib shell: operation: SMLib failed (status 1001)diff --git a/tests/kernel-cases/solids/KNOWN_FAILING.solidcore b/tests/kernel-cases/solids/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..3f60017a61--- /dev/null+++ b/tests/kernel-cases/solids/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The solids cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/surfaces/KNOWN_FAILING.solidcore b/tests/kernel-cases/surfaces/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..f06f0629c3--- /dev/null+++ b/tests/kernel-cases/surfaces/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The surfaces cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/sweeps/KNOWN_FAILING.solidcore b/tests/kernel-cases/sweeps/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..123b953f0f--- /dev/null+++ b/tests/kernel-cases/sweeps/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The sweeps cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/tessellation/KNOWN_FAILING.solidcore b/tests/kernel-cases/tessellation/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..b6d4bf06ab--- /dev/null+++ b/tests/kernel-cases/tessellation/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The tessellation cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/tests/kernel-cases/threads/KNOWN_FAILING.solidcore b/tests/kernel-cases/threads/KNOWN_FAILING.solidcorenew file mode 100644index 0000000000..6c945ac4b4--- /dev/null+++ b/tests/kernel-cases/threads/KNOWN_FAILING.solidcore@@ -0,0 +1,3 @@+# The threads cases that fail today on solidcore, one a line: `<case> <why it fails today>`. Sorted.+# The kernel rig gate fails on a case that fails and is not listed, and on a listed case that passes.+# Baseline: solidcore pin de85a3e00, tests/kernel-cases run by `cargo xtask kernel-cases`, x86_64 Linux.diff --git a/xtask/src/kernel_cases.rs b/xtask/src/kernel_cases.rsindex e931beb31e..35f3d66e06 100644--- a/xtask/src/kernel_cases.rs+++ b/xtask/src/kernel_cases.rs@@ -1,12 +1,18 @@//! `cargo xtask kernel-cases`: the kernel regression rig. Runs every case in-//! `tests/kernel-cases/<area>/<id>/` through `solidcraft-cli kernel-cases` on SMLib, one process-//! per case (so a crash or a hang is that case's result, not the run's), and writes-//! `docs/kernel-cases.md`: results per case, coverage per area and per source, and the issues and-//! PRs looked at and skipped. Each case is graded against its own answer.+//! `tests/kernel-cases/<area>/<id>/` through `solidcraft-cli kernel-cases` on solidcore, or the+//! C++ SMLib kernel when asked for, one process per case (so a crash or a hang is that case's result, not the run's), and writes+//! its report: results per case, coverage per area and per source, and the issues and PRs looked+//! at and skipped. Each case is graded against its own answer.//!//! The run's output folder (`--out`, default `target/kernel-cases`) holds `results.json`, every//! case's full result, and `dumps/<area>-<case>/`, the inputs of each SMLib call a case's run//! failed in (`solidcraft-cli kernel-cases --dumps`), for replay.+//!+//! `--kernel solidcore|smlib|both` (default solidcore) picks the backend each case's process runs+//! on (`SOLIDCRAFT_KERNEL`). A solidcore run keeps its results, dumps and report in+//! `<out>/solidcore/`; an smlib run writes `docs/kernel-cases.md`; `both` runs every case on each,+//! keeps `docs/kernel-cases.md` as the SMLib report and writes the side by side to+//! `docs/kernel-cases-backends.md` and `<out>/backends.json`.use std::collections::BTreeMap;use std::path::{Path, PathBuf};@@ -20,6 +26,9 @@ use crate::{cargo, root};const DEFAULT_TIMEOUT_S: u64 = 180;+/// The backends `--kernel` may name, as `SOLIDCRAFT_KERNEL` takes them.+const BACKENDS: [&str; 2] = ["smlib", "solidcore"];+/// How many cases ended in each status.type StatusCounts = BTreeMap<String, usize>;@@ -30,6 +39,8 @@ pub(crate) struct Options {pub(crate) jobs: usize,/// The run's output folder: `results.json` and the SMLib dumps (`dumps/`).out: PathBuf,+ /// The backends each case runs on (`--kernel`, default solidcore alone).+ pub(crate) kernels: Vec<&'static str>,/// `--known-failing FILE`: run as a regression gate against that baseline (see [`gate`]).known_failing: Option<PathBuf>,/// `--validation MODE`: when SMLib's full check runs on the cases' features (each_step,@@ -37,28 +48,56 @@ pub(crate) struct Options {validation: Option<String>,}+impl Options {+ /// A backend's output folder: the run's own for SMLib, `<out>/<backend>/` for any other.+ fn out_of(&self, kernel: &str) -> PathBuf {+ match kernel {+ "smlib" => self.out.clone(),+ other => self.out.join(other),+ }+ }+}+/// The run's options; `out` is its output folder unless `--out` gives one.pub(crate) fn options(rest: &[&str], out: &str) -> Result<Options, String> {let arg = |name: &str| rest.iter().position(|a| *a == name).and_then(|i| rest.get(i + 1)).map(|s| s.to_string());let secs = arg("--timeout").map(|t| t.parse::<u64>().map_err(|e| format!("--timeout: {e}"))).transpose()?.unwrap_or(DEFAULT_TIMEOUT_S);let jobs = arg("--jobs").map(|j| j.parse::<usize>().map_err(|e| format!("--jobs: {e}"))).transpose()?.unwrap_or(4).clamp(1, 32);let out = arg("--out").map_or_else(|| root().join(out), PathBuf::from);+ let kernels = match arg("--kernel").as_deref() {+ Some("smlib") => vec![BACKENDS[0]],+ None | Some("solidcore") => vec![BACKENDS[1]],+ Some("both") => BACKENDS.to_vec(),+ Some(k) => return Err(format!("--kernel: unknown backend '{k}' (smlib, solidcore or both)")),+ };+ if rest.contains(&"--route") {+ return Err("--route is gone: a run has one kernel, --kernel solidcore, smlib or both".into());+ }let known_failing = arg("--known-failing").map(|p| {let p = PathBuf::from(p);if p.is_absolute() { p } else { root().join(p) }});+ // A list is one kernel's: the gate grades the run's one kernel against it.+ if known_failing.is_some() && kernels.len() != 1 {+ return Err("--known-failing: a list is one kernel's, so not with --kernel both".into());+ }let validation = arg("--validation");if let Some(v) = validation.as_deref().filter(|v| !["each_step", "each_feature", "off"].contains(v)) {return Err(format!("--validation must be each_step, each_feature or off, not `{v}`"));}- Ok(Options { cli: arg("--cli"), area: arg("--area"), timeout: Duration::from_secs(secs), jobs, out, known_failing, validation })+ Ok(Options { cli: arg("--cli"), area: arg("--area"), timeout: Duration::from_secs(secs), jobs, out, kernels, known_failing, validation })}/// Every case's full result as JSON, into the run's output folder.pub(crate) fn save_results(o: &Options, results: &[Value]) -> Result<(), String> {- std::fs::create_dir_all(&o.out).map_err(|e| format!("{}: {e}", o.out.display()))?;- let path = o.out.join("results.json");- let text = serde_json::to_string_pretty(results).map_err(|e| e.to_string())?;+ save_json(&o.out, "results.json", results)+}++/// `value` as pretty JSON into `dir/name`.+fn save_json<T: serde::Serialize + ?Sized>(dir: &Path, name: &str, value: &T) -> Result<(), String> {+ std::fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;+ let path = dir.join(name);+ let text = serde_json::to_string_pretty(value).map_err(|e| e.to_string())?;std::fs::write(&path, text).map_err(|e| format!("{}: {e}", path.display()))}@@ -87,26 +126,66 @@ fn cases(dir: &Path, only: Option<&str>) -> Result<Vec<PathBuf>, String> {/// One case, in its own process, killed after the timeout; `path` is the case's directory under/// `tests/kernel-cases/`.-fn run_one(o: &Options, case: &Path) -> Value {- let mut r = run_case(o, case);+fn run_one(o: &Options, case: &Path, kernel: &str) -> Value {+ let mut r = run_case(o, case, kernel);let base = root().join("tests/kernel-cases");r["path"] = json!(case.strip_prefix(&base).unwrap_or(case).to_string_lossy().replace('\\', "/"));r}-fn run_case(o: &Options, case: &Path) -> Value {+/// Waits for `child` for at most `timeout` while reading its stdout and stderr, so a child that+/// writes more than the pipe buffer (64 KiB on Linux) is not blocked in `write` and taken for a+/// hang. `None`: the child was still running at the timeout and has been killed.+fn wait_draining(mut child: std::process::Child, timeout: Duration) -> Result<Option<std::process::Output>, String> {+ fn drain<R: std::io::Read + Send + 'static>(pipe: Option<R>) -> std::thread::JoinHandle<Vec<u8>> {+ std::thread::spawn(move || {+ let mut buf = Vec::new();+ if let Some(mut p) = pipe {+ let _ = p.read_to_end(&mut buf);+ }+ buf+ })+ }+ let (stdout, stderr) = (drain(child.stdout.take()), drain(child.stderr.take()));+ let start = Instant::now();+ let status = loop {+ match child.try_wait() {+ Ok(Some(status)) => break status,+ Ok(None) if start.elapsed() > timeout => {+ let _ = child.kill();+ let _ = child.wait();+ // The readers are left to finish on their own: a grandchild (`cargo run`'s CLI)+ // may still hold the pipes open.+ return Ok(None);+ }+ Ok(None) => std::thread::sleep(Duration::from_millis(50)),+ Err(e) => return Err(format!("wait: {e}")),+ }+ };+ let join = |h: std::thread::JoinHandle<Vec<u8>>| h.join().map_err(|_| "output: a pipe reader stopped".to_string());+ Ok(Some(std::process::Output { status, stdout: join(stdout)?, stderr: join(stderr)? }))+}++/// The features `cargo run` builds the CLI with for a run on `kernels`: the C++ kernel is opt-in at+/// build time (`--features smlib`), so only a run that asks for it builds it. One build for the+/// whole run (`both` included), so the cases don't rebuild the CLI between kernels.+fn cli_features(kernels: &[&str]) -> &'static [&'static str] {+ if kernels.contains(&"smlib") { &["--features", "smlib"] } else { &[] }+}++fn run_case(o: &Options, case: &Path, kernel: &str) -> Value {let rel = case.strip_prefix(root()).unwrap_or(case).to_path_buf();let mut cmd = match &o.cli {Some(bin) => Command::new(bin),None => {let mut c = cargo();- c.args(["run", "-q", "--release", "-p", "solidcraft-cli", "--features", "smlib", "--"]);+ c.args(["run", "-q", "--release", "-p", "solidcraft-cli"]).args(cli_features(&o.kernels)).arg("--");c}};let mut dumps = std::ffi::OsString::from("--dumps=");- dumps.push(o.out.join("dumps"));- cmd.current_dir(root()).args(["kernel-cases", "--json"]).arg(dumps);+ dumps.push(o.out_of(kernel).join("dumps"));+ cmd.env("SOLIDCRAFT_KERNEL", kernel).current_dir(root()).args(["kernel-cases", "--json"]).arg(dumps);if let Some(v) = &o.validation {cmd.arg(format!("--validation={v}"));}@@ -116,28 +195,17 @@ fn run_case(o: &Options, case: &Path) -> Value {let id = case.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default();json!({"case": id, "area": area, "status": status, "error": error})};- let mut child = match cmd.spawn() {+ let child = match cmd.spawn() {Ok(c) => c,Err(e) => return base("fail", format!("solidcraft-cli: {e}")),};// A case may need longer than the run's timeout (`timeout_s`, at most 30 min).let timeout = read(&case.join("expected.json"))["timeout_s"].as_u64().map_or(o.timeout, |s| Duration::from_secs(s.min(1800)).max(o.timeout));let start = Instant::now();- loop {- match child.try_wait() {- Ok(Some(_)) => break,- Ok(None) if start.elapsed() > timeout => {- let _ = child.kill();- let _ = child.wait();- return base("hang", format!("no result after {} s", timeout.as_secs()));- }- Ok(None) => std::thread::sleep(Duration::from_millis(50)),- Err(e) => return base("fail", format!("wait: {e}")),- }- }- let out = match child.wait_with_output() {- Ok(o) => o,- Err(e) => return base("fail", format!("output: {e}")),+ let out = match wait_draining(child, timeout) {+ Ok(Some(out)) => out,+ Ok(None) => return base("hang", format!("no result after {} s", timeout.as_secs())),+ Err(e) => return base("fail", e),};match serde_json::from_slice::<Value>(&out.stdout).ok().and_then(|v| v.as_array().and_then(|a| a.first().cloned())) {Some(mut r) => {@@ -154,11 +222,27 @@ fn run_case(o: &Options, case: &Path) -> Value {}}+/// Every case on the run's one backend (the ladder's: it refuses `--kernel both`).pub(crate) fn run_all(o: &Options, list: &[PathBuf]) -> Vec<Value> {+ run_on(o, list, &o.kernels).into_iter().next().unwrap_or_default()+}++/// Every case on each backend, one job pool for all the runs; the results per backend, in order.+fn run_on(o: &Options, list: &[PathBuf], kernels: &[&str]) -> Vec<Vec<Value>> {+ // Without --cli each case is `cargo run`: build the CLI once first, so the first cases don't+ // spend their timeout compiling it (the C++ kernel's build most of all).+ if o.cli.is_none() {+ let mut c = cargo();+ c.args(["build", "-q", "--release", "-p", "solidcraft-cli"]).args(cli_features(kernels));+ if let Err(e) = c.status().map_err(|e| e.to_string()).and_then(|s| if s.success() { Ok(()) } else { Err(s.to_string()) }) {+ eprintln!("kernel-cases: building solidcraft-cli failed ({e}); each case will say why");+ }+ }+ let jobs = list.len() * kernels.len();let next = Arc::new(Mutex::new(0usize));- let results = Arc::new(Mutex::new(vec![Value::Null; list.len()]));+ let results = Arc::new(Mutex::new(vec![Value::Null; jobs]));std::thread::scope(|s| {- for _ in 0..o.jobs.min(list.len().max(1)) {+ for _ in 0..o.jobs.min(jobs.max(1)) {let (next, results) = (Arc::clone(&next), Arc::clone(&results));s.spawn(move || {loop {@@ -168,9 +252,15 @@ pub(crate) fn run_all(o: &Options, list: &[PathBuf]) -> Vec<Value> {*n += 1;i};- let Some(case) = list.get(i) else { return };- let r = run_one(o, case);- println!("{:<11} {}", r["status"].as_str().unwrap_or("?").to_uppercase(), case.strip_prefix(root()).unwrap_or(case).display());+ // Case by case, each on every backend in turn.+ let (Some(case), Some(kernel)) = (list.get(i / kernels.len().max(1)), kernels.get(i % kernels.len().max(1))) else { return };+ let r = run_one(o, case, kernel);+ let tag = if kernels.len() > 1 { format!("{kernel:<10} ") } else { String::new() };+ println!(+ "{:<11} {tag}{}",+ r["status"].as_str().unwrap_or("?").to_uppercase(),+ case.strip_prefix(root()).unwrap_or(case).display()+ );if let Ok(mut all) = results.lock()&& let Some(slot) = all.get_mut(i){@@ -180,12 +270,12 @@ pub(crate) fn run_all(o: &Options, list: &[PathBuf]) -> Vec<Value> {});}});- Arc::try_unwrap(results).ok().and_then(|m| m.into_inner().ok()).unwrap_or_default()+ let all = Arc::try_unwrap(results).ok().and_then(|m| m.into_inner().ok()).unwrap_or_default();+ (0..kernels.len()).map(|k| all.iter().skip(k).step_by(kernels.len().max(1)).cloned().collect()).collect()}-pub(crate) fn cell(r: Option<&Value>) -> String {- let Some(r) = r else { return String::new() };- let status = r["status"].as_str().unwrap_or("?");+/// What went wrong in a result: its failed checks, then its error.+fn notes(r: &Value) -> Vec<String> {let mut notes: Vec<String> = r["checks"].as_array().into_iter()@@ -196,6 +286,13 @@ pub(crate) fn cell(r: Option<&Value>) -> String {if let Some(e) = r["error"].as_str() {notes.push(e.chars().take(160).collect());}+ notes+}++pub(crate) fn cell(r: Option<&Value>) -> String {+ let Some(r) = r else { return String::new() };+ let status = r["status"].as_str().unwrap_or("?");+ let notes = notes(r);let s = match status {"pass" => "pass".to_string(),"unsupported" => "not supported yet".to_string(),@@ -256,7 +353,9 @@ fn source_kinds(dir: &Path, cited: &BTreeMap<String, Vec<String>>) -> Result<StrOk(md)}-fn write_report(dir: &Path, list: &[PathBuf], results: &[Value]) -> Result<String, String> {+/// The report of one backend's run into `to` (relative to the repository root, or absolute);+/// `kernel` is the backend's label, `env` what its processes were given.+fn write_report(dir: &Path, list: &[PathBuf], results: &[Value], kernel: &str, env: &str, to: &Path) -> Result<String, String> {let key = |r: &Value| (r["area"].as_str().unwrap_or("").to_string(), r["case"].as_str().unwrap_or("").to_string());let by_case: BTreeMap<(String, String), &Value> = results.iter().map(|r| (key(r), r)).collect();// Coverage: per area, cases and their statuses; per source, its cases.@@ -289,6 +388,9 @@ fn write_report(dir: &Path, list: &[PathBuf], results: &[Value]) -> Result<Strinlet mut md = String::from("# Kernel regression rig\n\nGenerated by `cargo xtask kernel-cases`. Every geometry case the old kernel (truck) got wrong, as an issue, a PR or a crash report recorded it, is a use case in [`tests/kernel-cases/`](../tests/kernel-cases/) with its own right answer: numbers from analysis or a hand calculation (**analytic**) where the geometry has them, and otherwise the invariants (**invariants**): the operation succeeds, or refuses cleanly where that is the right answer; each body is one closed shell that passes the record's structure and geometry checks and SMLib's own check; the expected face, edge and vertex counts. Never a kernel's output, and never a commercial kernel's.\n\nThe cases run on SMLib, SolidCraft's kernel. A failing case stays failing until the kernel is fixed; there is no workaround on SolidCraft's side. A failed SMLib call leaves its inputs for replay in the run's output folder (`target/kernel-cases/dumps/<area>-<case>/`). See [`tests/kernel-cases/README.md`](../tests/kernel-cases/README.md) for the format. Every area is also a regression gate: CI's Kernel rig workflow runs them on every pull request that touches the kernel and fails on a case that fails and its area's `KNOWN_FAILING` (such as [`fillets/KNOWN_FAILING`](../tests/kernel-cases/fillets/KNOWN_FAILING)) does not list, or a listed case that passes.\n\n",);+ if kernel != "smlib" {+ md += &format!("**This run: `{env}`.**\n\n");+ }md += "## Coverage\n\n| Area | Cases | Results |\n|---|---|---|\n";for (area, (n, statuses)) in &areas {md += &format!("| {area} | {n} | {} |\n", statuses.iter().map(|(s, c)| format!("{c} {s}")).collect::<Vec<_>>().join(", "));@@ -335,13 +437,96 @@ fn write_report(dir: &Path, list: &[PathBuf], results: &[Value]) -> Result<Strinif skipped == 0 {md += "None yet.\n";}- std::fs::write(root().join("docs/kernel-cases.md"), md).map_err(|e| format!("docs/kernel-cases.md: {e}"))?;+ let path = root().join(to);+ let shown = path.strip_prefix(root()).unwrap_or(&path).display().to_string();+ std::fs::write(&path, md).map_err(|e| format!("{shown}: {e}"))?;let pass = results.iter().filter(|r| r["status"] == "pass").count();- Ok(format!("kernel-cases: {pass}/{} pass → docs/kernel-cases.md ({skipped} skipped sources listed)", list.len()))+ let on = if kernel == "smlib" { String::new() } else { format!(" on {kernel}") };+ Ok(format!("kernel-cases: {pass}/{} pass{on} → {shown} ({skipped} skipped sources listed)", list.len()))+}++/// pass, fail, or other (crash, hang, not supported yet...), for the summary.+fn bucket(status: &str) -> &'static str {+ match status {+ "pass" => "pass",+ "fail" => "fail",+ _ => "other",+ }+}++/// A result's commands' time (or, without one, its process's).+fn seconds(r: &Value) -> Option<f64> {+ r["seconds"].as_f64().or_else(|| r["process_seconds"].as_f64())+}++/// The two backends side by side: per case (area, id) each one's status, time and what went wrong,+/// as JSON, and the Markdown report: a summary, then per area the cases that differ first.+fn side_by_side(smlib: &[Value], solidcore: &[Value]) -> (Value, String) {+ let key = |r: &Value| (r["area"].as_str().unwrap_or("").to_string(), r["case"].as_str().unwrap_or("").to_string());+ let mut pairs: BTreeMap<(String, String), [Option<&Value>; 2]> = BTreeMap::new();+ for (k, rs) in [smlib, solidcore].iter().enumerate() {+ for r in rs.iter().filter(|r| !r.is_null()) {+ if let Some(slot) = pairs.entry(key(r)).or_default().get_mut(k) {+ *slot = Some(r);+ }+ }+ }+ let status = |r: Option<&Value>| r.and_then(|r| r["status"].as_str()).unwrap_or("not run").to_string();+ let mut rows = Vec::new();+ let (mut counts, mut times, mut agree) = ([StatusCounts::new(), StatusCounts::new()], [0.0f64; 2], 0);+ for ((area, case), runs) in &pairs {+ let same = status(runs[0]) == status(runs[1]);+ agree += usize::from(same);+ let mut row = json!({"case": case, "area": area, "agree": same});+ for (k, name) in BACKENDS.iter().enumerate() {+ let r = runs[k];+ *counts[k].entry(bucket(&status(r)).to_string()).or_default() += 1;+ times[k] += r.and_then(seconds).unwrap_or(0.0);+ let error = r.map(|r| notes(r).join("; ")).filter(|e| !e.is_empty());+ row[*name] = json!({"status": status(r), "seconds": r.and_then(seconds), "error": error});+ }+ rows.push(row);+ }+ let differ = pairs.len() - agree;+ let mut md = String::from(+ "# Kernel regression rig: SMLib and solidcore\n\nGenerated by `cargo xtask kernel-cases --kernel both`: every case in [`tests/kernel-cases/`](../tests/kernel-cases/) run on each backend (`SOLIDCRAFT_KERNEL`), graded against its own answer. Times are the commands' own. [`kernel-cases.md`](kernel-cases.md) is the SMLib run in full.\n\n",+ );+ md += "## Summary\n\n| Backend | Pass | Fail | Other | Time (s) |\n|---|---|---|---|---|\n";+ for (k, name) in BACKENDS.iter().enumerate() {+ let n = |b: &str| counts[k].get(b).copied().unwrap_or(0);+ md += &format!("| {name} | {} | {} | {} | {:.1} |\n", n("pass"), n("fail"), n("other"), times[k]);+ }+ md += &format!("\n{} cases: {agree} agree, {differ} differ.\n", pairs.len());+ let side = |r: &Value| match r["seconds"].as_f64() {+ Some(s) => format!("{} ({s:.2} s)", r["status"].as_str().unwrap_or("?")),+ None => r["status"].as_str().unwrap_or("?").to_string(),+ };+ let mut by_area: BTreeMap<&str, Vec<&Value>> = BTreeMap::new();+ for row in &rows {+ by_area.entry(row["area"].as_str().unwrap_or("")).or_default().push(row);+ }+ for (area, mut list) in by_area {+ list.sort_by_key(|r| (r["agree"].as_bool().unwrap_or(false), r["case"].as_str().unwrap_or("").to_string()));+ md += &format!("\n## {area}\n\n| Case | {} | {} | |\n|---|---|---|---|\n", BACKENDS[0], BACKENDS[1]);+ for r in list {+ let mark = if r["agree"].as_bool().unwrap_or(false) { "" } else { "**differ**" };+ md += &format!("| {} | {} | {} | {mark} |\n", r["case"].as_str().unwrap_or(""), side(&r["smlib"]), side(&r["solidcore"]));+ }+ }+ let summary: Value = BACKENDS+ .iter()+ .enumerate()+ .map(|(k, name)| (name.to_string(), json!({"counts": counts[k], "seconds": times[k]})))+ .collect::<serde_json::Map<_, _>>()+ .into();+ (json!({"summary": summary, "agree": agree, "differ": differ, "cases": rows}), md)}pub fn run(rest: &[&str]) -> Result<(), String> {if rest.contains(&"--ladder") {+ if options(rest, "target/kernel-ladder")?.kernels.len() != 1 {+ return Err("--kernel: the ladder runs on one backend, smlib or solidcore".into());+ }return crate::kernel_ladder::run(rest);}let o = options(rest, "target/kernel-cases")?;@@ -354,18 +539,39 @@ pub fn run(rest: &[&str]) -> Result<(), String> {if list.is_empty() {return Err(format!("no cases (recipe.json + expected.json) under {}", dir.display()));}- let results = run_all(&o, &list);- save_results(&o, &results)?;+ let runs = run_on(&o, &list, &o.kernels);+ for (kernel, results) in o.kernels.iter().zip(&runs) {+ save_json(&o.out_of(kernel), "results.json", results)?;+ }if let Some(file) = &o.known_failing {- // A gate run grades one set against its baseline; the report stays the full run's.+ // A gate run grades the run's one kernel against its baseline, and writes no report; its+ // results.json is still saved above.let text = std::fs::read_to_string(file).map_err(|e| format!("{}: {e}", file.display()))?;let base = file.parent().unwrap_or(&dir);let paths: Vec<String> = list.iter().map(|c| c.strip_prefix(base).unwrap_or(c).to_string_lossy().replace('\\', "/")).collect();- let statuses: Vec<&str> = results.iter().map(|r| r["status"].as_str().unwrap_or("?")).collect();+ let graded = runs.first().ok_or("--known-failing: no run to grade")?;+ let statuses: Vec<&str> = graded.iter().map(|r| r["status"].as_str().unwrap_or("?")).collect();println!("{}", gate(&text, &paths, &statuses).map_err(|e| format!("{}: {e}", file.display()))?);return Ok(());}- println!("{}", write_report(&dir, &list, &results)?);+ for (kernel, results) in o.kernels.iter().zip(&runs) {+ let out = o.out_of(kernel);+ let to = if *kernel == "smlib" { PathBuf::from("docs/kernel-cases.md") } else { out.join("report.md") };+ let env = format!("SOLIDCRAFT_KERNEL={kernel}");+ println!("{}", write_report(&dir, &list, results, kernel, &env, &to)?);+ }+ if let [smlib, solidcore] = runs.as_slice() {+ let (data, md) = side_by_side(smlib, solidcore);+ let into = o.out.clone();+ save_json(&into, "backends.json", &data)?;+ std::fs::write(root().join("docs/kernel-cases-backends.md"), md).map_err(|e| format!("docs/kernel-cases-backends.md: {e}"))?;+ println!(+ "kernel-cases: {} agree, {} differ → docs/kernel-cases-backends.md, {}",+ data["agree"],+ data["differ"],+ into.join("backends.json").display()+ );+ }Ok(())}@@ -563,9 +769,91 @@ fn run_coverage(o: &Options, dir: &Path) -> Result<String, String> {#[cfg(test)]mod tests {- use super::{Exempt, coverage, exempt, gate, recipe_commands};+ use super::*;++ /// A child that writes more than the pipe buffer still finishes, with all its output.+ #[cfg(unix)]+ #[test]+ fn a_child_writing_more_than_the_pipe_buffer_is_not_a_hang() {+ let child = Command::new("sh")+ .args(["-c", "head -c 200000 /dev/zero; head -c 100000 /dev/zero >&2"])+ .stdout(Stdio::piped())+ .stderr(Stdio::piped())+ .spawn()+ .unwrap();+ let out = wait_draining(child, Duration::from_secs(60)).unwrap().unwrap();+ assert!(out.status.success());+ assert_eq!((out.stdout.len(), out.stderr.len()), (200_000, 100_000));+ let slow = Command::new("sh").args(["-c", "sleep 30"]).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();+ let t = Instant::now();+ assert!(wait_draining(slow, Duration::from_millis(200)).unwrap().is_none());+ assert!(t.elapsed() < Duration::from_secs(20));+ }++ #[test]+ fn side_by_side_counts_and_puts_differences_first() {+ let r = |area: &str, case: &str, status: &str, s: f64| json!({"area": area, "case": case, "status": status, "seconds": s});+ let smlib = [r("booleans", "a", "pass", 1.0), r("booleans", "b", "pass", 2.0), r("shell", "c", "crash", 0.5)];+ let mut hang = json!({"area": "booleans", "case": "b", "status": "hang", "error": "no result after 180 s"});+ hang["process_seconds"] = json!(180.0);+ let solidcore = [r("booleans", "a", "pass", 0.5), hang, r("shell", "c", "fail", 1.5)];+ let (data, md) = side_by_side(&smlib, &solidcore);+ assert_eq!((data["agree"].as_u64(), data["differ"].as_u64()), (Some(1), Some(2)));+ assert_eq!(data["summary"]["smlib"]["counts"], json!({"pass": 2, "other": 1}));+ assert_eq!(data["summary"]["solidcore"]["counts"], json!({"pass": 1, "fail": 1, "other": 1}));+ assert_eq!(data["summary"]["solidcore"]["seconds"].as_f64(), Some(182.0));+ let b = data["cases"].as_array().and_then(|c| c.iter().find(|c| c["case"] == "b")).cloned().unwrap_or_default();+ assert_eq!((b["solidcore"]["status"].as_str(), b["solidcore"]["error"].as_str()), (Some("hang"), Some("no result after 180 s")));+ // In booleans, b (differs) comes before a (agrees).+ let (pos_a, pos_b) = (md.find("| a |"), md.find("| b |"));+ assert!(pos_b.is_some() && pos_a.is_some() && pos_b < pos_a, "{md}");+ assert!(md.contains("| b | pass (2.00 s) | hang (180.00 s) | **differ** |"), "{md}");+ assert!(md.contains("3 cases: 1 agree, 2 differ."), "{md}");+ }++ /// `--route`, the old per-family run, is no option: each case's process has one kernel. Passed+ /// anyway, it is refused rather than run as something else.+ #[test]+ fn a_kernel_has_its_own_folder_and_route_is_refused() {+ let o = options(&["--kernel", "both", "--out", "/r"], "x").unwrap();+ assert_eq!((o.out_of("smlib"), o.out_of("solidcore")), (PathBuf::from("/r"), PathBuf::from("/r/solidcore")));+ assert!(options(&["--route", "boolean=solidcore"], "x").is_err());+ assert!(options(&["--kernel", "both", "--route"], "x").is_err());+ }++ /// `--known-failing` follows the kernel given, solidcore by default: a list is one kernel's.+ #[test]+ fn the_gate_grades_the_kernel_given() {+ for (args, kernel) in [+ (&["--known-failing", "/k"][..], "solidcore"),+ (&["--kernel", "solidcore", "--known-failing", "/k"], "solidcore"),+ (&["--kernel", "smlib", "--known-failing", "/k"], "smlib"),+ ] {+ let o = options(args, "x").unwrap();+ assert_eq!((o.known_failing, o.kernels), (Some(PathBuf::from("/k")), vec![kernel]), "{args:?}");+ }+ assert!(options(&["--kernel", "both", "--known-failing", "/k"], "x").is_err());+ }++ /// With no `--kernel`, a run is on solidcore; the C++ kernel is asked for.+ #[test]+ fn the_rig_defaults_to_solidcore() {+ assert_eq!(options(&[], "x").unwrap().kernels, ["solidcore"]);+ assert_eq!(options(&["--kernel", "smlib"], "x").unwrap().kernels, ["smlib"]);+ assert_eq!(options(&["--kernel", "both"], "x").unwrap().kernels, ["smlib", "solidcore"]);+ }++ /// Only a run that asks for the C++ kernel builds the CLI with it.+ #[test]+ fn the_cli_is_built_with_the_cpp_kernel_only_when_a_run_asks_for_it() {+ let features = |args: &[&str]| cli_features(&options(args, "x").unwrap().kernels).to_vec();+ assert!(features(&[]).is_empty());+ assert!(features(&["--kernel", "solidcore"]).is_empty());+ assert_eq!(features(&["--kernel", "smlib"]), ["--features", "smlib"]);+ assert_eq!(features(&["--kernel", "both"]), ["--features", "smlib"]);+ }- fn run(text: &str, cases: &[(&str, &str)]) -> Result<String, String> {+ fn gate_on(text: &str, cases: &[(&str, &str)]) -> Result<String, String> {let names: Vec<String> = cases.iter().map(|(c, _)| c.to_string()).collect();let statuses: Vec<&str> = cases.iter().map(|(_, s)| *s).collect();gate(text, &names, &statuses)@@ -574,20 +862,20 @@ mod tests {#[test]fn the_gate_fails_on_a_regression_and_on_a_fixed_case_still_listed() {let list = "# today\na-case SMLib refuses the corner\nb-case G1 at the corner point\n";- assert!(run(list, &[("a-case", "fail"), ("b-case", "crash"), ("c-case", "pass")]).is_ok());- let regression = run(list, &[("a-case", "fail"), ("b-case", "fail"), ("c-case", "hang")]).unwrap_err();+ assert!(gate_on(list, &[("a-case", "fail"), ("b-case", "crash"), ("c-case", "pass")]).is_ok());+ let regression = gate_on(list, &[("a-case", "fail"), ("b-case", "fail"), ("c-case", "hang")]).unwrap_err();assert!(regression.contains("REGRESSION (hang): c-case"), "{regression}");- let fixed = run(list, &[("a-case", "pass"), ("b-case", "fail"), ("c-case", "pass")]).unwrap_err();+ let fixed = gate_on(list, &[("a-case", "pass"), ("b-case", "fail"), ("c-case", "pass")]).unwrap_err();assert!(fixed.contains("FIXED, remove it from the known-failing list: a-case"), "{fixed}");- let stale = run(list, &[("a-case", "fail"), ("c-case", "pass")]).unwrap_err();+ let stale = gate_on(list, &[("a-case", "fail"), ("c-case", "pass")]).unwrap_err();assert!(stale.contains("not a case of this set: b-case"), "{stale}");}#[test]fn the_known_failing_list_is_sorted_with_a_cause_each() {- assert!(run("b x\na y\n", &[("a", "fail"), ("b", "fail")]).unwrap_err().contains("out of order"));- assert!(run("a x\na y\n", &[("a", "fail")]).unwrap_err().contains("a repeat of"));- assert!(run("a\n", &[("a", "fail")]).unwrap_err().contains("gives no cause"));+ assert!(gate_on("b x\na y\n", &[("a", "fail"), ("b", "fail")]).unwrap_err().contains("out of order"));+ assert!(gate_on("a x\na y\n", &[("a", "fail")]).unwrap_err().contains("a repeat of"));+ assert!(gate_on("a\n", &[("a", "fail")]).unwrap_err().contains("gives no cause"));}#[test]diff --git a/xtask/src/kernel_ladder.rs b/xtask/src/kernel_ladder.rsindex 978b904871..840b4db254 100644--- a/xtask/src/kernel_ladder.rs+++ b/xtask/src/kernel_ladder.rs@@ -3,7 +3,7 @@//! `tests/kernel-cases/ladder/ladder.json` lists tiers in order of complexity and, per tier, its//! cases in order (paths under `tests/kernel-cases/`, so a tier may also list rig cases from other//! areas). Each case is a test like any rig case, graded against its own `expected.json`, on-//! SMLib. On top, `tests/kernel-cases/ladder/golden.json` records per case the status, the+//! `--kernel`'s one backend. The golden is SMLib's, so a gate or a record says `--kernel smlib`. On top, `tests/kernel-cases/ladder/golden.json` records per case the status, the//! commands' time and what was made (counts, volume, area): the run compares with it and flags//! slowdowns and changes; cases run one at a time unless `--jobs` says otherwise, so the times are//! not shared with other cases. `--record REASON` re-measures the golden and re-sorts each tierdiff --git a/xtask/src/known_failing.rs b/xtask/src/known_failing.rsindex b85b3a0c93..5a213cae1e 100644--- a/xtask/src/known_failing.rs+++ b/xtask/src/known_failing.rs@@ -1,6 +1,7 @@//! `cargo xtask known-failing --junit PATH... [--list FILE]`: grades a nextest run (its junit-//! report) against the tests known to fail today, `tests/KNOWN_FAILING_TESTS`. CI's test jobs-//! run it after nextest, in place of failing on any failed test. It fails on a test that failed+//! report) against the tests known to fail today on the default kernel,+//! `tests/KNOWN_FAILING_TESTS` (the C++ kernel's are `tests/KNOWN_FAILING_TESTS.smlib`, for a run+//! with `SOLIDCRAFT_KERNEL=smlib` and `--list`). CI's test jobs run it after nextest, in place of failing on any failed test. It fails on a test that failed//! and is not listed, and on a listed test that passed (fixed: its line comes off in the same//! pull request); a listed test that did not run (a pull request tests only the packages it//! touches) is neither. The list has the kernel rig's format (`kernel_cases::known_failing`):@@ -15,6 +16,8 @@ use quick_xml::Reader;use quick_xml::events::{BytesStart, Event};pub const LIST: &str = "tests/KNOWN_FAILING_TESTS";+/// The same for the C++ kernel (`SOLIDCRAFT_KERNEL=smlib`), graded with `--list`.+pub const SMLIB_LIST: &str = "tests/KNOWN_FAILING_TESTS.smlib";pub fn run(root: &Path, rest: &[&str]) -> Result<(), String> {let mut reports = Vec::new();@@ -60,9 +63,12 @@ fn add(all: &mut BTreeMap<String, bool>, xml: &str) -> Result<(), String> {/// `cargo xtask lists`: the list is sorted, each test once, with a cause each.pub fn check_list(root: &Path) -> Result<(), String> {- let file = root.join(LIST);- let text = std::fs::read_to_string(&file).map_err(|e| format!("{}: {e}", file.display()))?;- crate::kernel_cases::known_failing(&text).map(|_| ()).map_err(|e| format!("{LIST}: {e}"))+ for list in [LIST, SMLIB_LIST] {+ let file = root.join(list);+ let text = std::fs::read_to_string(&file).map_err(|e| format!("{}: {e}", file.display()))?;+ crate::kernel_cases::known_failing(&text).map_err(|e| format!("{list}: {e}"))?;+ }+ Ok(())}/// `path` itself, or every `.xml` file under it (sorted), into `out`.diff --git a/xtask/src/lists.rs b/xtask/src/lists.rsindex 920c8dfe58..4e5588cce8 100644--- a/xtask/src/lists.rs+++ b/xtask/src/lists.rs@@ -5,7 +5,7 @@//!//! - The message catalogs (`assets/locales/*.json`): one message per line, sorted by id, no//! duplicate ids, as `serde_json` pretty-prints them.-//! - `tests/KNOWN_FAILING_TESTS`: one test a line with its cause, sorted, each test once+//! - `tests/KNOWN_FAILING_TESTS` and `.smlib`: one test a line with its cause, sorted, each test once//! (checked only; `cargo xtask known-failing` reads it).//! - Growing Rust lists: no written array lengths on more than ten lines of entries.diff --git a/xtask/src/main.rs b/xtask/src/main.rsindex d1438bf2c4..949c2e1b32 100644--- a/xtask/src/main.rs+++ b/xtask/src/main.rs@@ -49,21 +49,29 @@ commands:replay the reference tests (tests/oracle/*/recipe.json), compare with eachcase's expected.json and write docs/oracle.md (--cli: a solidcraft-clialready built, instead of cargo run --release)- kernel-cases [--area AREA] [--cli BIN] [--timeout S] [--jobs N] [--out DIR] [--known-failing FILE] [--validation MODE] [--coverage]+ kernel-cases [--area AREA] [--cli BIN] [--timeout S] [--jobs N] [--out DIR] [--kernel K] [--route R] [--known-failing FILE] [--validation MODE] [--coverage]the kernel regression rig: run every case in tests/kernel-cases/<area>/<id>/ on- SMLib (one process each, killed after --timeout, default 180 s), grade it against- the case's own answer and write docs/kernel-cases.md; DIR (default- target/kernel-cases) gets results.json and dumps/<area>-<case>/, the inputs of- each failing SMLib call (--cli: a solidcraft-cli built with --features smlib)+ solidcore (one process each, killed after --timeout, default 180 s), grade it against+ the case's own answer; DIR (default target/kernel-cases) gets results.json and+ dumps/<area>-<case>/, the inputs of each failing SMLib call (--cli: a+ solidcraft-cli already built);+ --kernel solidcore|smlib|both (default solidcore) sets SOLIDCRAFT_KERNEL per case:+ solidcore keeps results.json, dumps/ and report.md in DIR/solidcore/; smlib+ writes docs/kernel-cases.md; both runs each case on each, and also writes the+ side by side to docs/kernel-cases-backends.md and DIR/backends.json; smlib and+ both need the C++ kernel, so without --cli they build the CLI with --features smlib+ (a --cli built without it reports every case as unsupported)--known-failing FILE: a regression gate instead of the report: fails on a casethat fails and FILE does not list, and on a listed case that passes- (tests/kernel-cases/<area>/KNOWN_FAILING, CI's Kernel rig workflow)+ (tests/kernel-cases/<area>/KNOWN_FAILING, CI's Kernel rig workflow); it grades+ the run's kernel, so a list is one kernel's (KNOWN_FAILING.solidcore,+ KNOWN_FAILING for --kernel smlib) and --kernel both is refused--validation MODE: when SMLib's full check runs on the cases' features:each_step, each_feature (the default) or off (solidcraft-cli kernel-cases--validation=MODE); with --ladder too--ladder [--record REASON | --gate]: the complexity ladder instead(tests/kernel-cases/ladder/ladder.json, tiers in order), graded and compared- with its timing golden (one case at a time unless --jobs), into+ with its timing golden (one case at a time unless --jobs), on --kernel's one backend, intodocs/kernel-ladder.md (DIR default target/kernel-ladder); --record re-measuresthe golden and re-sorts each tier by time; --gate fails on any case whose statusor counts differ from the golden, instead of the report@@ -72,7 +80,8 @@ commands:uses and tests/kernel-cases/EXEMPT does not list, and on a stale EXEMPT lineknown-failing --junit PATH... [--list FILE]grade a nextest run's junit report (a file, or every .xml under a directory)- against the tests known to fail today, tests/KNOWN_FAILING_TESTS (FILE): fails+ against the tests known to fail today on the default kernel,+ tests/KNOWN_FAILING_TESTS (FILE: .smlib is the C++ kernel's): failson a test that failed and is not listed, and on a listed test that passed(fixed: take its line off); a listed test that did not run is neither. CI'stest jobs run it after nextest