Skip to content

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.yml
index 1e6eb58063..513596eade 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -442,9 +442,6 @@ jobs:
with:
key: quick-compile
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: Cargo check
run: cargo check --workspace --all-targets --locked
@@ -464,9 +461,6 @@ jobs:
with:
key: native-clippy
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: Clippy
env:
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; fi
cargo 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 warnings
build-tests:
name: Build tests
@@ -510,9 +511,6 @@ jobs:
with:
key: native-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:
@@ -584,9 +582,6 @@ jobs:
with:
key: native-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:
@@ -640,6 +635,69 @@ jobs:
path: ${{ env.CARGO_TARGET_DIR || 'target' }}/nextest/ci/junit.xml
retention-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-gpu
save-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 cache
uses: mozilla-actions/sccache-action@fc920bf0ec8de6ee65d409111f7ec508035751ba # v0.0.11
with:
@@ -862,9 +917,6 @@ jobs:
with:
key: doc-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:
@@ -923,9 +975,6 @@ jobs:
with:
key: oracle
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:
@@ -965,9 +1014,6 @@ jobs:
with:
key: windows-fxc
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
# 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-startup
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: Backend order and probing on Windows
run: 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-2404
permissions:
@@ -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" = success
fi
test "$TESTS" = success
+ test "$CPP_TESTS" = success
fi
# 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: wasm
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 wasm32-unknown-unknown
- run: cargo xtask wasm
riscv64-gates:
@@ -1157,9 +1199,6 @@ jobs:
with:
key: riscv64
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 riscv64gc-unknown-linux-gnu
- name: Install cross-compilation dependencies
run: |
# Ubuntu's regular archive serves amd64; RISC-V packages live in ports.
@@ -1180,8 +1219,6 @@ jobs:
- name: Cargo check on RISC-V
env:
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/pkgconfig
PKG_CONFIG_ALLOW_CROSS: 1
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
index cf1c396915..0e7d17e09c 100644
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -53,9 +53,6 @@ jobs:
with:
key: docker-web
save-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 trunk
run: |
mkdir -p "$HOME/.local/bin"
diff --git a/.github/workflows/external-corpus.yml b/.github/workflows/external-corpus.yml
index 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 CLI
run: cargo build --profile ci -p solidcraft-cli
- name: Import and check every entry
diff --git a/.github/workflows/fillet-rig.yml b/.github/workflows/fillet-rig.yml
index 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-rig
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
- - 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 list
run: >-
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 results
if: always()
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
diff --git a/.github/workflows/generated.yml b/.github/workflows/generated.yml
index 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.2
with:
key: generated-files
- - name: Fetch SMLib (crates/smlib/SMLIB_REV)
- shell: bash
- run: scripts/fetch-smlib.sh
- name: THIRD-PARTY-LICENSES.txt
run: cargo xtask licences
- name: docs/features.md
diff --git a/.github/workflows/kernel-rig.yml b/.github/workflows/kernel-rig.yml
index 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 smlib
else
- set -- --area "$SHARD" --known-failing "tests/kernel-cases/$SHARD/KNOWN_FAILING"
+ set -- --area "$SHARD" --known-failing "tests/kernel-cases/$SHARD/KNOWN_FAILING.solidcore"
fi
target/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.2
with:
name: kernel-rig-results-${{ matrix.shard }}
- path: ${{ runner.temp }}/kernel-rig/results.json
+ path: ${{ runner.temp }}/kernel-rig/**/results.json
if-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.yml
index 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 trunk
run: |
mkdir -p "$HOME/.local/bin"
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 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.2
with:
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.2
with:
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.2
with:
key: release-macos-${{ matrix.arch }}
- - name: Fetch SMLib (crates/smlib/SMLIB_REV)
- shell: bash
- run: scripts/fetch-smlib.sh ${{ matrix.target }}
- name: Build
run: 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.2
with:
key: release-windows-${{ matrix.arch }}
- - name: Fetch SMLib (crates/smlib/SMLIB_REV)
- shell: bash
- run: scripts/fetch-smlib.sh ${{ matrix.target }}
- name: Install WiX
shell: pwsh
run: |
@@ -630,9 +618,6 @@ jobs:
- uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
with:
key: release-web
- - name: Fetch SMLib (crates/smlib/SMLIB_REV)
- shell: bash
- run: scripts/fetch-smlib.sh wasm32-unknown-unknown
- name: Install trunk
run: |
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.md
index 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 library
FreeCAD `.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 code
diff --git a/Cargo.lock b/Cargo.lock
index 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.toml
index 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.toml
index 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.rs
index 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: solidcraft
return 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 result
diff --git a/apps/solidcraft-cli/tests/model_cache.rs b/apps/solidcraft-cli/tests/model_cache.rs
index 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.toml
index 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.rs
new file mode 100644
index 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.toml
index 5e3bfc360b..6860706a12 100644
--- a/apps/solidcraft/Cargo.toml
+++ b/apps/solidcraft/Cargo.toml
@@ -8,11 +8,12 @@ publish = false
default-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.json
new file mode 100644
index 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.toml
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.toml
index 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.rs
index 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.rs
index 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.toml
index 7d922123c6..29afa888f7 100644
--- a/crates/kernel/Cargo.toml
+++ b/crates/kernel/Cargo.toml
@@ -9,9 +9,9 @@ license.workspace = true
workspace = 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.rs
index 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 end
diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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). Only
diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rs
index 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.rs
index 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.toml
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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(&degree) || !(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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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(&degrees), None).map_err(|e| ("SmCircle::CreateCanonical", e))?
+ } else {
+ Ellipse::create_canonical(k, &placement, r1, r2, Some(&degrees), None).map_err(|e| ("SmEllipse::CreateCanonical", e))?
+ };
+ e.edit_parameterization(k, &degrees, 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.rs
new file mode 100644
index 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[&REGION_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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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[&REGION_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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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, &notch, 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, &notch, 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.rs
new file mode 100644
index 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(&copy, 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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(&center) || ![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(&degrees), 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(&degree) || 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, &section, 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(&degree) {
+ 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(&degree)
+ || 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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, &copy_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.rs
new file mode 100644
index 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.rs
index 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(&center, radius).map(Brep).map_err(error)
+ ffi::make_sphere(&center, 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(&center, major_radius, minor_radius).map(Brep).map_err(error)
+ ffi::make_torus(&center, 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::Surfac
v3(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.rs
index 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 the
diff --git a/crates/smlib/src/flat.rs b/crates/smlib/src/flat.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 fixture
fn 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 fixture
fn 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 fixture
fn 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/oracle
diff --git a/crates/smlib/src/ops.rs b/crates/smlib/src/ops.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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(&center, &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(&center, &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.rs
index 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(&degree) {
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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.toml
index c24dbb4c7f..6769a37209 100644
--- a/deny.toml
+++ b/deny.toml
@@ -13,3 +13,5 @@ allow-wildcard-paths = true
unknown-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.md
index 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 every
STEP, mesh and image payload) and of `cache/bodies.bin`, the slices, each kernel
body'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 both
digests 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 a
digest of the committed source a model is computed from: the `doc` crate and every
diff --git a/docs/perf.md b/docs/perf.md
index 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.py
index 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_TESTS
index 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 SMLib
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::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 SMLib
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-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.smlib
new file mode 100644
index 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 established
diff --git a/tests/kernel-cases/README.md b/tests/kernel-cases/README.md
index 3bae0e8fb9..517ed227cb 100644
--- a/tests/kernel-cases/README.md
+++ b/tests/kernel-cases/README.md
@@ -1,17 +1,22 @@
# Kernel regression rig
Every 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 solidcore
cargo 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 each
SMLib 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 rig
once), `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 coverage
Every area is a regression suite: each case is one small case of one issue, with its exact
answer. `.github/workflows/kernel-rig.yml` runs them, and the ladder, on pull requests (not
drafts). 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 per
selected area plus the ladder, runs them in parallel; the `kernel-rig` check passes when every
selected shard does (and when none was selected). Pushes to main and develop, merge groups, the
release gate (`release-gate.yml`) and a run by hand run every area. Each area's shard runs:
```sh
cargo 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 its
cause (`<case> <why it fails today>`; `#` starts a comment; the header names the baseline: the
develop commit and SMLib revision it was taken from). The gate fails on a **regression**, a
case 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 rig
gate 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 the
diff --git a/tests/kernel-cases/assemblies/KNOWN_FAILING.solidcore b/tests/kernel-cases/assemblies/KNOWN_FAILING.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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 seam
diff --git a/tests/kernel-cases/frames/KNOWN_FAILING.solidcore b/tests/kernel-cases/frames/KNOWN_FAILING.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.solidcore
new file mode 100644
index 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.rs
index 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<Str
Ok(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<Strin
let 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<Strin
if 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.rs
index 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 tier
diff --git a/xtask/src/known_failing.rs b/xtask/src/known_failing.rs
index 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.rs
index 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.rs
index 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 each
case's expected.json and write docs/oracle.md (--cli: a solidcraft-cli
already 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 case
that 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, into
docs/kernel-ladder.md (DIR default target/kernel-ladder); --record re-measures
the golden and re-sorts each tier by time; --gate fails on any case whose status
or 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 line
known-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): fails
on 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's
test jobs run it after nextest