SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
M0: workspace, geometry foundation, sketch constraint solver, kernel boundary
bherbruckdafce1f4e205
diff --git a/.cargo/config.toml b/.cargo/config.tomlnew file mode 100644index 0000000000..35049cbcb1--- /dev/null+++ b/.cargo/config.toml@@ -0,0 +1,2 @@+[alias]+xtask = "run --package xtask --"diff --git a/.gitignore b/.gitignorenew file mode 100644index 0000000000..e30dd0a825--- /dev/null+++ b/.gitignore@@ -0,0 +1,7 @@+/target+/plan/+/dist/+*~+.DS_Store+*.swp+/.claude/worktrees/diff --git a/Cargo.lock b/Cargo.locknew file mode 100644index 0000000000..9c69f3e96f--- /dev/null+++ b/Cargo.lock@@ -0,0 +1,1388 @@+# This file is automatically @generated by Cargo.+# It is not intended for manual editing.+version = 4++[[package]]+name = "Inflector"+version = "0.11.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"+dependencies = [+ "lazy_static",+ "regex",+]++[[package]]+name = "ahash"+version = "0.8.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"+dependencies = [+ "cfg-if",+ "getrandom 0.3.4",+ "once_cell",+ "version_check",+ "zerocopy",+]++[[package]]+name = "aho-corasick"+version = "1.1.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"+dependencies = [+ "memchr",+]++[[package]]+name = "allocator-api2"+version = "0.2.21"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"++[[package]]+name = "android_system_properties"+version = "0.1.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc"+dependencies = [+ "libc",+]++[[package]]+name = "approx"+version = "0.4.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3f2a05fd1bd10b2527e20a2cd32d8873d115b8b39fe219ee25f42a8aca6ba278"+dependencies = [+ "num-traits",+]++[[package]]+name = "array-macro"+version = "2.1.8"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "220a2c618ab466efe41d0eace94dfeff1c35e3aa47891bdb95e1c0fefffd3c99"++[[package]]+name = "autocfg"+version = "1.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"++[[package]]+name = "bitflags"+version = "2.13.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"++[[package]]+name = "branches"+version = "0.4.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7436b21fd6195415058eb41c9090e156b556bc7e0377bb57c5c026a421521525"+dependencies = [+ "rustc_version",+]++[[package]]+name = "bumpalo"+version = "3.20.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"++[[package]]+name = "bytemuck"+version = "1.25.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797"+dependencies = [+ "bytemuck_derive",+]++[[package]]+name = "bytemuck_derive"+version = "1.12.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6a1f896587b6f2c069c73d2f0913e2d590c3990285cd2f0b6aa02b786b4c679c"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 3.0.6",+]++[[package]]+name = "cc"+version = "1.6.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f74872d07caf508b30a21f6836e7d7016a2eaf7d9ff4f48deaa58cd8a0407630"+dependencies = [+ "find-msvc-tools",+ "shlex",+]++[[package]]+name = "cfg-if"+version = "1.0.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"++[[package]]+name = "cgmath"+version = "0.18.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1a98d30140e3296250832bbaaff83b27dcd6fa3cc70fb6f1f3e5c9c0023b5317"+dependencies = [+ "approx",+ "num-traits",+ "serde",+]++[[package]]+name = "chacha20"+version = "0.10.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"+dependencies = [+ "cfg-if",+ "cpufeatures",+ "rand_core",+]++[[package]]+name = "chrono"+version = "0.4.45"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"+dependencies = [+ "iana-time-zone",+ "js-sys",+ "num-traits",+ "wasm-bindgen",+ "windows-link",+]++[[package]]+name = "convert_case"+version = "0.10.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"+dependencies = [+ "unicode-segmentation",+]++[[package]]+name = "core-foundation-sys"+version = "0.8.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"++[[package]]+name = "cpufeatures"+version = "0.3.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566"+dependencies = [+ "libc",+]++[[package]]+name = "crossbeam-deque"+version = "0.8.8"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"+dependencies = [+ "crossbeam-epoch",+ "crossbeam-utils",+]++[[package]]+name = "crossbeam-epoch"+version = "0.9.21"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d"+dependencies = [+ "crossbeam-utils",+]++[[package]]+name = "crossbeam-utils"+version = "0.8.23"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"++[[package]]+name = "derive-new"+version = "0.7.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2cdc8d50f426189eef89dac62fabfa0abb27d5cc008f25bf4156a0203325becc"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 2.0.119",+]++[[package]]+name = "derive_more"+version = "2.1.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"+dependencies = [+ "derive_more-impl",+]++[[package]]+name = "derive_more-impl"+version = "2.1.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"+dependencies = [+ "convert_case",+ "proc-macro2",+ "quote",+ "rustc_version",+ "syn 2.0.119",+ "unicode-xid",+]++[[package]]+name = "either"+version = "1.19.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be"++[[package]]+name = "equivalent"+version = "1.0.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"++[[package]]+name = "find-msvc-tools"+version = "0.1.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484"++[[package]]+name = "foldhash"+version = "0.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"++[[package]]+name = "futures-core"+version = "0.3.34"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"++[[package]]+name = "futures-task"+version = "0.3.34"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"++[[package]]+name = "futures-util"+version = "0.3.34"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"+dependencies = [+ "futures-core",+ "futures-task",+ "pin-project-lite",+ "slab",+]++[[package]]+name = "getrandom"+version = "0.3.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"+dependencies = [+ "cfg-if",+ "js-sys",+ "libc",+ "r-efi 5.3.0",+ "wasip2",+ "wasm-bindgen",+]++[[package]]+name = "getrandom"+version = "0.4.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"+dependencies = [+ "cfg-if",+ "js-sys",+ "libc",+ "r-efi 6.0.0",+ "rand_core",+ "wasm-bindgen",+]++[[package]]+name = "hashbrown"+version = "0.16.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"+dependencies = [+ "allocator-api2",+ "equivalent",+ "foldhash",+]++[[package]]+name = "hashbrown"+version = "0.17.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"++[[package]]+name = "iana-time-zone"+version = "0.1.65"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"+dependencies = [+ "android_system_properties",+ "core-foundation-sys",+ "iana-time-zone-haiku",+ "js-sys",+ "log",+ "wasm-bindgen",+ "windows-core",+]++[[package]]+name = "iana-time-zone-haiku"+version = "0.1.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"+dependencies = [+ "cc",+]++[[package]]+name = "indexmap"+version = "2.14.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"+dependencies = [+ "equivalent",+ "hashbrown 0.17.1",+]++[[package]]+name = "itertools"+version = "0.14.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"+dependencies = [+ "either",+]++[[package]]+name = "itertools"+version = "0.15.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"+dependencies = [+ "either",+]++[[package]]+name = "itoa"+version = "1.0.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"++[[package]]+name = "js-sys"+version = "0.3.106"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5"+dependencies = [+ "cfg-if",+ "futures-util",+ "wasm-bindgen",+]++[[package]]+name = "katexit"+version = "0.1.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ccfb0b7ce7938f84a5ecbdca5d0a991e46bc9d6d078934ad5e92c5270fe547db"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 2.0.119",+]++[[package]]+name = "lazy_static"+version = "1.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb"++[[package]]+name = "libc"+version = "0.2.190"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78"++[[package]]+name = "lock_api"+version = "0.4.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"+dependencies = [+ "scopeguard",+]++[[package]]+name = "log"+version = "0.4.34"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"++[[package]]+name = "matext4cgmath"+version = "0.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e6541e181de37f70f0aceb25441823a3d0efa9cc1d23f475a0d3926678949178"+dependencies = [+ "cgmath",+ "katexit",+ "num-complex",+]++[[package]]+name = "memchr"+version = "2.8.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"++[[package]]+name = "monstertruck-assembly"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a1041107e797756c1176344c81461d7bb7298ee00c3e9ee5adf093d14f627d56"+dependencies = [+ "monstertruck-core",+ "rayon",+]++[[package]]+name = "monstertruck-core"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6f34f2f284b16af3672085cdcaf5d6521feecc104bacf1a37f1fac6c8c1a5884"+dependencies = [+ "cgmath",+ "matext4cgmath",+ "rustc-hash",+ "serde",+ "xxhash-rust",+]++[[package]]+name = "monstertruck-derive"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "05c2cdecf25f2d799557e29b5b8c9b6db4d766d150e29aad6d4bba5204f2ea58"+dependencies = [+ "proc-macro-error",+ "proc-macro2",+ "quote",+ "syn 2.0.119",+]++[[package]]+name = "monstertruck-fillet"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "512bba6a317473cd83210019054373af9d13af4273417f28ee54bee5d16bc6c3"+dependencies = [+ "ahash",+ "derive_more",+ "getrandom 0.3.4",+ "itertools 0.14.0",+ "monstertruck-core",+ "monstertruck-geometry",+ "monstertruck-meshing",+ "monstertruck-topology",+ "monstertruck-traits",+ "smallvec",+ "thiserror",+]++[[package]]+name = "monstertruck-geometry"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cee8ce45200826a20c752ae24c82f5048dcddd2f168230c1799c214b804d6f40"+dependencies = [+ "monstertruck-core",+ "monstertruck-traits",+ "parking_lot",+ "serde",+ "smallvec",+ "thiserror",+]++[[package]]+name = "monstertruck-io"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b9db95ba8ed9ba913084f04e865b8e522813f9885f40497b8717ede6c6f1542e"+dependencies = [+ "chrono",+ "derive_more",+ "monstertruck-assembly",+ "monstertruck-core",+ "monstertruck-derive",+ "monstertruck-geometry",+ "monstertruck-mesh",+ "monstertruck-modeling",+ "monstertruck-topology",+ "monstertruck-traits",+ "serde",+ "step-p21",+ "thiserror",+ "web-time",+]++[[package]]+name = "monstertruck-mesh"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "875dbf22ba985790b87e652bfaa1ed24852d3746b1ac022ac7b6c28ba35121c6"+dependencies = [+ "array-macro",+ "bytemuck",+ "itertools 0.14.0",+ "monstertruck-core",+ "monstertruck-traits",+ "rayon",+ "rustc-hash",+ "serde",+ "thiserror",+]++[[package]]+name = "monstertruck-meshing"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ea03901ea0b3cfaf380c1cc8c2efee85500cdfe260c38bb8278c2a66a18de939"+dependencies = [+ "array-macro",+ "derive_more",+ "itertools 0.14.0",+ "log",+ "monstertruck-core",+ "monstertruck-geometry",+ "monstertruck-mesh",+ "monstertruck-topology",+ "rayon",+ "rustc-hash",+ "spade",+ "web-time",+]++[[package]]+name = "monstertruck-modeling"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "518f0c01eb240558e830d6734ab88dc0bf559923811553302aa1f3c16051c211"+dependencies = [+ "derive_more",+ "itertools 0.14.0",+ "monstertruck-core",+ "monstertruck-fillet",+ "monstertruck-geometry",+ "monstertruck-mesh",+ "monstertruck-topology",+ "monstertruck-traits",+ "rayon",+ "rustc-hash",+ "serde",+ "thiserror",+ "web-time",+]++[[package]]+name = "monstertruck-solid"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "29e8fab1d370bfe553a171c0b0948810eefc66ecb2e3dca87e26c985bda27e50"+dependencies = [+ "ahash",+ "derive_more",+ "getrandom 0.3.4",+ "itertools 0.14.0",+ "monstertruck-core",+ "monstertruck-geometry",+ "monstertruck-meshing",+ "monstertruck-topology",+ "monstertruck-traits",+ "rustc-hash",+ "serde",+ "smallvec",+ "thiserror",+]++[[package]]+name = "monstertruck-topology"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "def1bdeca2fd361435fec506495aaade7caba299accfbb4da1997a1bc300faf5"+dependencies = [+ "monstertruck-core",+ "monstertruck-traits",+ "parking_lot",+ "rayon",+ "rclite",+ "rustc-hash",+ "serde",+ "thiserror",+]++[[package]]+name = "monstertruck-traits"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "77b8f72eb09b5f613f6ccc314c53bc4c43de1a0d1d5a29eae61f8b9b8b04eed1"+dependencies = [+ "getrandom 0.4.3",+ "monstertruck-core",+ "monstertruck-derive",+ "num-traits",+ "rand",+ "thiserror",+]++[[package]]+name = "nom"+version = "8.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"+dependencies = [+ "memchr",+]++[[package]]+name = "nom-language"+version = "0.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2de2bc5b451bfedaef92c90b8939a8fff5770bdcc1fafd6239d086aab8fa6b29"+dependencies = [+ "nom",+]++[[package]]+name = "num-complex"+version = "0.4.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"+dependencies = [+ "num-traits",+]++[[package]]+name = "num-traits"+version = "0.2.19"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"+dependencies = [+ "autocfg",+]++[[package]]+name = "once_cell"+version = "1.21.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"++[[package]]+name = "parking_lot"+version = "0.12.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"+dependencies = [+ "lock_api",+ "parking_lot_core",+]++[[package]]+name = "parking_lot_core"+version = "0.9.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"+dependencies = [+ "cfg-if",+ "libc",+ "redox_syscall",+ "smallvec",+ "windows-link",+]++[[package]]+name = "pin-project-lite"+version = "0.2.17"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"++[[package]]+name = "proc-macro-crate"+version = "3.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"+dependencies = [+ "toml_edit",+]++[[package]]+name = "proc-macro-error"+version = "1.0.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"+dependencies = [+ "proc-macro-error-attr",+ "proc-macro2",+ "quote",+ "syn 1.0.109",+ "version_check",+]++[[package]]+name = "proc-macro-error-attr"+version = "1.0.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"+dependencies = [+ "proc-macro2",+ "quote",+ "version_check",+]++[[package]]+name = "proc-macro-error-attr2"+version = "2.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"+dependencies = [+ "proc-macro2",+ "quote",+]++[[package]]+name = "proc-macro-error2"+version = "2.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"+dependencies = [+ "proc-macro-error-attr2",+ "proc-macro2",+ "quote",+ "syn 2.0.119",+]++[[package]]+name = "proc-macro2"+version = "1.0.107"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"+dependencies = [+ "unicode-ident",+]++[[package]]+name = "quote"+version = "1.0.47"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"+dependencies = [+ "proc-macro2",+]++[[package]]+name = "r-efi"+version = "5.3.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"++[[package]]+name = "r-efi"+version = "6.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"++[[package]]+name = "rand"+version = "0.10.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af"+dependencies = [+ "chacha20",+ "getrandom 0.4.3",+ "rand_core",+]++[[package]]+name = "rand_core"+version = "0.10.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"++[[package]]+name = "rayon"+version = "1.12.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"+dependencies = [+ "either",+ "rayon-core",+]++[[package]]+name = "rayon-core"+version = "1.13.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"+dependencies = [+ "crossbeam-deque",+ "crossbeam-utils",+]++[[package]]+name = "rclite"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c6716a637a8a17bce72da6b6ddab8548619cc748658c41ab6ee5c4a3c1001385"+dependencies = [+ "branches",+]++[[package]]+name = "redox_syscall"+version = "0.5.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"+dependencies = [+ "bitflags",+]++[[package]]+name = "regex"+version = "1.13.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"+dependencies = [+ "aho-corasick",+ "memchr",+ "regex-automata",+ "regex-syntax",+]++[[package]]+name = "regex-automata"+version = "0.4.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"+dependencies = [+ "aho-corasick",+ "memchr",+ "regex-syntax",+]++[[package]]+name = "regex-syntax"+version = "0.8.11"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"++[[package]]+name = "robust"+version = "1.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4e27ee8bb91ca0adcf0ecb116293afa12d393f9c2b9b9cd54d33e8078fe19839"++[[package]]+name = "rustc-hash"+version = "2.1.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"++[[package]]+name = "rustc_version"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"+dependencies = [+ "semver",+]++[[package]]+name = "rustversion"+version = "1.0.23"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"++[[package]]+name = "scopeguard"+version = "1.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"++[[package]]+name = "semver"+version = "1.0.28"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"++[[package]]+name = "serde"+version = "1.0.229"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"+dependencies = [+ "serde_core",+ "serde_derive",+]++[[package]]+name = "serde_core"+version = "1.0.229"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"+dependencies = [+ "serde_derive",+]++[[package]]+name = "serde_derive"+version = "1.0.229"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 3.0.6",+]++[[package]]+name = "serde_json"+version = "1.0.151"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"+dependencies = [+ "itoa",+ "memchr",+ "serde",+ "serde_core",+ "zmij",+]++[[package]]+name = "shlex"+version = "2.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"++[[package]]+name = "slab"+version = "0.4.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"++[[package]]+name = "smallvec"+version = "1.16.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e"++[[package]]+name = "solvecraft"+version = "0.1.0"++[[package]]+name = "solvecraft-cli"+version = "0.1.0"++[[package]]+name = "solvecraft-doc"+version = "0.1.0"++[[package]]+name = "solvecraft-engine"+version = "0.1.0"++[[package]]+name = "solvecraft-geom"+version = "0.1.0"+dependencies = [+ "serde",+ "serde_json",+]++[[package]]+name = "solvecraft-io"+version = "0.1.0"++[[package]]+name = "solvecraft-kernel"+version = "0.1.0"+dependencies = [+ "log",+ "monstertruck-io",+ "monstertruck-meshing",+ "monstertruck-modeling",+ "monstertruck-solid",+ "serde",+ "solvecraft-geom",+ "thiserror",+]++[[package]]+name = "solvecraft-render"+version = "0.1.0"++[[package]]+name = "solvecraft-sketch"+version = "0.1.0"+dependencies = [+ "serde",+ "serde_json",+ "solvecraft-geom",+ "thiserror",+]++[[package]]+name = "solvecraft-ui-egui"+version = "0.1.0"++[[package]]+name = "spade"+version = "2.15.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9699399fd9349b00b184f5635b074f9ec93afffef30c853f8c875b32c0f8c7fa"+dependencies = [+ "hashbrown 0.16.1",+ "num-traits",+ "robust",+ "smallvec",+]++[[package]]+name = "step-p21"+version = "0.1.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "261fb24eb3fd1de07c36523c41063ea901cde514594603cb6dfe7afe64f1b967"+dependencies = [+ "Inflector",+ "derive-new",+ "derive_more",+ "itertools 0.15.0",+ "nom",+ "nom-language",+ "serde",+ "step-p21-derive",+ "thiserror",+]++[[package]]+name = "step-p21-derive"+version = "0.1.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "432f60e41744c351a88a444fbe134ca9bb8d930c6442fe6334728963ba5dd782"+dependencies = [+ "Inflector",+ "proc-macro-crate",+ "proc-macro-error2",+ "proc-macro2",+ "quote",+ "syn 3.0.6",+]++[[package]]+name = "syn"+version = "1.0.109"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"+dependencies = [+ "proc-macro2",+ "unicode-ident",+]++[[package]]+name = "syn"+version = "2.0.119"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"+dependencies = [+ "proc-macro2",+ "quote",+ "unicode-ident",+]++[[package]]+name = "syn"+version = "3.0.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"+dependencies = [+ "proc-macro2",+ "quote",+ "unicode-ident",+]++[[package]]+name = "thiserror"+version = "2.0.21"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e"+dependencies = [+ "thiserror-impl",+]++[[package]]+name = "thiserror-impl"+version = "2.0.21"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 3.0.6",+]++[[package]]+name = "toml_datetime"+version = "1.1.1+spec-1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"+dependencies = [+ "serde_core",+]++[[package]]+name = "toml_edit"+version = "0.25.15+spec-1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1340ea94a5856333492c9064b02c778b191dd2c853778d9609debdcdfea3a614"+dependencies = [+ "indexmap",+ "toml_datetime",+ "toml_parser",+ "winnow",+]++[[package]]+name = "toml_parser"+version = "1.1.3+spec-1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56"+dependencies = [+ "winnow",+]++[[package]]+name = "unicode-ident"+version = "1.0.26"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"++[[package]]+name = "unicode-segmentation"+version = "1.13.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"++[[package]]+name = "unicode-xid"+version = "0.2.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"++[[package]]+name = "version_check"+version = "0.9.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"++[[package]]+name = "wasip2"+version = "1.0.4+wasi-0.2.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"+dependencies = [+ "wit-bindgen",+]++[[package]]+name = "wasm-bindgen"+version = "0.2.129"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"+dependencies = [+ "cfg-if",+ "once_cell",+ "rustversion",+ "wasm-bindgen-macro",+ "wasm-bindgen-shared",+]++[[package]]+name = "wasm-bindgen-macro"+version = "0.2.129"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"+dependencies = [+ "quote",+ "wasm-bindgen-macro-support",+]++[[package]]+name = "wasm-bindgen-macro-support"+version = "0.2.129"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"+dependencies = [+ "bumpalo",+ "proc-macro2",+ "quote",+ "syn 3.0.6",+ "wasm-bindgen-shared",+]++[[package]]+name = "wasm-bindgen-shared"+version = "0.2.129"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"+dependencies = [+ "unicode-ident",+]++[[package]]+name = "web-time"+version = "1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"+dependencies = [+ "js-sys",+ "wasm-bindgen",+]++[[package]]+name = "windows-core"+version = "0.62.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"+dependencies = [+ "windows-implement",+ "windows-interface",+ "windows-link",+ "windows-result",+ "windows-strings",+]++[[package]]+name = "windows-implement"+version = "0.60.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 2.0.119",+]++[[package]]+name = "windows-interface"+version = "0.59.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 2.0.119",+]++[[package]]+name = "windows-link"+version = "0.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"++[[package]]+name = "windows-result"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"+dependencies = [+ "windows-link",+]++[[package]]+name = "windows-strings"+version = "0.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"+dependencies = [+ "windows-link",+]++[[package]]+name = "winnow"+version = "1.0.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81"+dependencies = [+ "memchr",+]++[[package]]+name = "wit-bindgen"+version = "0.57.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"++[[package]]+name = "xtask"+version = "0.1.0"+dependencies = [+ "serde_json",+]++[[package]]+name = "xxhash-rust"+version = "0.8.19"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "550a2b930b62486a393c52d5c3b84bff264b28aa437ed64694d31e93b1757af7"++[[package]]+name = "zerocopy"+version = "0.8.61"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "879fb705ce98c32e41ebdb970fbe1204f8492423b314c6ab0354c3e7b5542866"+dependencies = [+ "zerocopy-derive",+]++[[package]]+name = "zerocopy-derive"+version = "0.8.61"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "708882a28301d604fa039cc7727607a98d04c4b86dc76ec9cc683f805d709759"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 2.0.119",+]++[[package]]+name = "zmij"+version = "1.0.23"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"diff --git a/Cargo.toml b/Cargo.tomlnew file mode 100644index 0000000000..f69b017fc4--- /dev/null+++ b/Cargo.toml@@ -0,0 +1,66 @@+[workspace]+resolver = "3"+members = ["crates/*", "apps/*", "xtask"]++[workspace.package]+version = "0.1.0"+edition = "2024"+license = "MIT OR Apache-2.0"+rust-version = "1.90"+authors = ["SolveCraft contributors"]+repository = "https://github.com/storytold/solvecraft"++[workspace.dependencies]+# internal+solvecraft-geom = { path = "crates/geom" }+solvecraft-sketch = { path = "crates/sketch" }+solvecraft-kernel = { path = "crates/kernel" }+solvecraft-render = { path = "crates/render" }+solvecraft-doc = { path = "crates/doc" }+solvecraft-io = { path = "crates/io" }+solvecraft-engine = { path = "crates/engine" }+solvecraft-ui-egui = { path = "crates/ui-egui" }++# foundation+thiserror = "2"+serde = { version = "1", features = ["derive", "rc"] }+serde_json = { version = "1", features = ["float_roundtrip"] }+log = "0.4"++# geometry kernel (Apache-2.0; see plan/adr/0001-geometry-kernel.md). Only crates/kernel uses it.+monstertruck-modeling = { version = "0.4.1", features = ["fillet"] }+monstertruck-solid = "0.4.1"+monstertruck-meshing = "0.4.1"+monstertruck-io = "0.4.1"++# images+image = { version = "0.25", default-features = false, features = ["png"] }++# ui+egui = "0.36"+eframe = { version = "0.36", default-features = false }+egui-wgpu = "0.36"+rfd = "0.17"++[workspace.lints.rust]+unsafe_code = "forbid"++[workspace.lints.clippy]+dbg_macro = "warn"+todo = "warn"+too_many_arguments = "allow"+type_complexity = "allow"+# `!(x > tol)` is our idiom for "not a usable number" (NaN-safe).+neg_cmp_op_on_partial_ord = "allow"++[profile.dev.package."*"]+opt-level = 2++[profile.dev]+opt-level = 1++[profile.release]+opt-level = 3+lto = "thin"+codegen-units = 16+debug = 0diff --git a/LICENSE-APACHE b/LICENSE-APACHEnew file mode 100644index 0000000000..f433b1a53f--- /dev/null+++ b/LICENSE-APACHE@@ -0,0 +1,177 @@++ Apache License+ Version 2.0, January 2004+ http://www.apache.org/licenses/++ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION++ 1. Definitions.++ "License" shall mean the terms and conditions for use, reproduction,+ and distribution as defined by Sections 1 through 9 of this document.++ "Licensor" shall mean the copyright owner or entity authorized by+ the copyright owner that is granting the License.++ "Legal Entity" shall mean the union of the acting entity and all+ other entities that control, are controlled by, or are under common+ control with that entity. For the purposes of this definition,+ "control" means (i) the power, direct or indirect, to cause the+ direction or management of such entity, whether by contract or+ otherwise, or (ii) ownership of fifty percent (50%) or more of the+ outstanding shares, or (iii) beneficial ownership of such entity.++ "You" (or "Your") shall mean an individual or Legal Entity+ exercising permissions granted by this License.++ "Source" form shall mean the preferred form for making modifications,+ including but not limited to software source code, documentation+ source, and configuration files.++ "Object" form shall mean any form resulting from mechanical+ transformation or translation of a Source form, including but+ not limited to compiled object code, generated documentation,+ and conversions to other media types.++ "Work" shall mean the work of authorship, whether in Source or+ Object form, made available under the License, as indicated by a+ copyright notice that is included in or attached to the work+ (an example is provided in the Appendix below).++ "Derivative Works" shall mean any work, whether in Source or Object+ form, that is based on (or derived from) the Work and for which the+ editorial revisions, annotations, elaborations, or other modifications+ represent, as a whole, an original work of authorship. For the purposes+ of this License, Derivative Works shall not include works that remain+ separable from, or merely link (or bind by name) to the interfaces of,+ the Work and Derivative Works thereof.++ "Contribution" shall mean any work of authorship, including+ the original version of the Work and any modifications or additions+ to that Work or Derivative Works thereof, that is intentionally+ submitted to Licensor for inclusion in the Work by the copyright owner+ or by an individual or Legal Entity authorized to submit on behalf of+ the copyright owner. For the purposes of this definition, "submitted"+ means any form of electronic, verbal, or written communication sent+ to the Licensor or its representatives, including but not limited to+ communication on electronic mailing lists, source code control systems,+ and issue tracking systems that are managed by, or on behalf of, the+ Licensor for the purpose of discussing and improving the Work, but+ excluding communication that is conspicuously marked or otherwise+ designated in writing by the copyright owner as "Not a Contribution."++ "Contributor" shall mean Licensor and any individual or Legal Entity+ on behalf of whom a Contribution has been received by Licensor and+ subsequently incorporated within the Work.++ 2. Grant of Copyright License. Subject to the terms and conditions of+ this License, each Contributor hereby grants to You a perpetual,+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable+ copyright license to reproduce, prepare Derivative Works of,+ publicly display, publicly perform, sublicense, and distribute the+ Work and such Derivative Works in Source or Object form.++ 3. Grant of Patent License. Subject to the terms and conditions of+ this License, each Contributor hereby grants to You a perpetual,+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable+ (except as stated in this section) patent license to make, have made,+ use, offer to sell, sell, import, and otherwise transfer the Work,+ where such license applies only to those patent claims licensable+ by such Contributor that are necessarily infringed by their+ Contribution(s) alone or by combination of their Contribution(s)+ with the Work to which such Contribution(s) was submitted. If You+ institute patent litigation against any entity (including a+ cross-claim or counterclaim in a lawsuit) alleging that the Work+ or a Contribution incorporated within the Work constitutes direct+ or contributory patent infringement, then any patent licenses+ granted to You under this License for that Work shall terminate+ as of the date such litigation is filed.++ 4. Redistribution. You may reproduce and distribute copies of the+ Work or Derivative Works thereof in any medium, with or without+ modifications, and in Source or Object form, provided that You+ meet the following conditions:++ (a) You must give any other recipients of the Work or+ Derivative Works a copy of this License; and++ (b) You must cause any modified files to carry prominent notices+ stating that You changed the files; and++ (c) You must retain, in the Source form of any Derivative Works+ that You distribute, all copyright, patent, trademark, and+ attribution notices from the Source form of the Work,+ excluding those notices that do not pertain to any part of+ the Derivative Works; and++ (d) If the Work includes a "NOTICE" text file as part of its+ distribution, then any Derivative Works that You distribute must+ include a readable copy of the attribution notices contained+ within such NOTICE file, excluding those notices that do not+ pertain to any part of the Derivative Works, in at least one+ of the following places: within a NOTICE text file distributed+ as part of the Derivative Works; within the Source form or+ documentation, if provided along with the Derivative Works; or,+ within a display generated by the Derivative Works, if and+ wherever such third-party notices normally appear. The contents+ of the NOTICE file are for informational purposes only and+ do not modify the License. You may add Your own attribution+ notices within Derivative Works that You distribute, alongside+ or as an addendum to the NOTICE text from the Work, provided+ that such additional attribution notices cannot be construed+ as modifying the License.++ You may add Your own copyright statement to Your modifications and+ may provide additional or different license terms and conditions+ for use, reproduction, or distribution of Your modifications, or+ for any such Derivative Works as a whole, provided Your use,+ reproduction, and distribution of the Work otherwise complies with+ the conditions stated in this License.++ 5. Submission of Contributions. Unless You explicitly state otherwise,+ any Contribution intentionally submitted for inclusion in the Work+ by You to the Licensor shall be under the terms and conditions of+ this License, without any additional terms or conditions.+ Notwithstanding the above, nothing herein shall supersede or modify+ the terms of any separate license agreement you may have executed+ with Licensor regarding such Contributions.++ 6. Trademarks. This License does not grant permission to use the trade+ names, trademarks, service marks, or product names of the Licensor,+ except as required for reasonable and customary use in describing the+ origin of the Work and reproducing the content of the NOTICE file.++ 7. Disclaimer of Warranty. Unless required by applicable law or+ agreed to in writing, Licensor provides the Work (and each+ Contributor provides its Contributions) on an "AS IS" BASIS,+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or+ implied, including, without limitation, any warranties or conditions+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A+ PARTICULAR PURPOSE. You are solely responsible for determining the+ appropriateness of using or redistributing the Work and assume any+ risks associated with Your exercise of permissions under this License.++ 8. Limitation of Liability. In no event and under no legal theory,+ whether in tort (including negligence), contract, or otherwise,+ unless required by applicable law (such as deliberate and grossly+ negligent acts) or agreed to in writing, shall any Contributor be+ liable to You for damages, including any direct, indirect, special,+ incidental, or consequential damages of any character arising as a+ result of this License or out of the use or inability to use the+ Work (including but not limited to damages for loss of goodwill,+ work stoppage, computer failure or malfunction, or any and all+ other commercial damages or losses), even if such Contributor+ has been advised of the possibility of such damages.++ 9. Accepting Warranty or Additional Liability. While redistributing+ the Work or Derivative Works thereof, You may choose to offer,+ and charge a fee for, acceptance of support, warranty, indemnity,+ or other liability obligations and/or rights consistent with this+ License. However, in accepting such obligations, You may act only+ on Your own behalf and on Your sole responsibility, not on behalf+ of any other Contributor, and only if You agree to indemnify,+ defend, and hold each Contributor harmless for any liability+ incurred by, or claims asserted against, such Contributor by reason+ of your accepting any such warranty or additional liability.++ END OF TERMS AND CONDITIONSdiff --git a/LICENSE-MIT b/LICENSE-MITnew file mode 100644index 0000000000..d19e8efe7c--- /dev/null+++ b/LICENSE-MIT@@ -0,0 +1,21 @@+MIT License++Copyright (c) 2026 SolveCraft contributors++Permission is hereby granted, free of charge, to any person obtaining a copy+of this software and associated documentation files (the "Software"), to deal+in the Software without restriction, including without limitation the rights+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+copies of the Software, and to permit persons to whom the Software is+furnished to do so, subject to the following conditions:++The above copyright notice and this permission notice shall be included in all+copies or substantial portions of the Software.++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE+SOFTWARE.diff --git a/apps/solvecraft-cli/Cargo.toml b/apps/solvecraft-cli/Cargo.tomlnew file mode 100644index 0000000000..bbefa761df--- /dev/null+++ b/apps/solvecraft-cli/Cargo.toml@@ -0,0 +1,5 @@+[package]+name = "solvecraft-cli"+version.workspace = true+edition.workspace = true+license.workspace = truediff --git a/apps/solvecraft-cli/src/main.rs b/apps/solvecraft-cli/src/main.rsnew file mode 100644index 0000000000..f328e4d9d0--- /dev/null+++ b/apps/solvecraft-cli/src/main.rs@@ -0,0 +1 @@+fn main() {}diff --git a/apps/solvecraft/Cargo.toml b/apps/solvecraft/Cargo.tomlnew file mode 100644index 0000000000..5f08b89dac--- /dev/null+++ b/apps/solvecraft/Cargo.toml@@ -0,0 +1,5 @@+[package]+name = "solvecraft"+version.workspace = true+edition.workspace = true+license.workspace = truediff --git a/apps/solvecraft/src/main.rs b/apps/solvecraft/src/main.rsnew file mode 100644index 0000000000..f328e4d9d0--- /dev/null+++ b/apps/solvecraft/src/main.rs@@ -0,0 +1 @@+fn main() {}diff --git a/clippy.toml b/clippy.tomlnew file mode 100644index 0000000000..4b6c79f555--- /dev/null+++ b/clippy.toml@@ -0,0 +1,4 @@+allow-unwrap-in-tests = true+allow-expect-in-tests = true+allow-panic-in-tests = true+allow-indexing-slicing-in-tests = truediff --git a/crates/doc/Cargo.toml b/crates/doc/Cargo.tomlnew file mode 100644index 0000000000..44cd085216--- /dev/null+++ b/crates/doc/Cargo.toml@@ -0,0 +1,8 @@+[package]+name = "solvecraft-doc"+version.workspace = true+edition.workspace = true+license.workspace = true++[lints]+workspace = truediff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rsnew file mode 100644index 0000000000..8b13789179--- /dev/null+++ b/crates/doc/src/lib.rs@@ -0,0 +1 @@+diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.tomlnew file mode 100644index 0000000000..de800ca14d--- /dev/null+++ b/crates/engine/Cargo.toml@@ -0,0 +1,8 @@+[package]+name = "solvecraft-engine"+version.workspace = true+edition.workspace = true+license.workspace = true++[lints]+workspace = truediff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsnew file mode 100644index 0000000000..8b13789179--- /dev/null+++ b/crates/engine/src/lib.rs@@ -0,0 +1 @@+diff --git a/crates/geom/Cargo.toml b/crates/geom/Cargo.tomlnew file mode 100644index 0000000000..498ce4e60f--- /dev/null+++ b/crates/geom/Cargo.toml@@ -0,0 +1,15 @@+[package]+name = "solvecraft-geom"+description = "SolveCraft geometry foundation: vectors, planes, frames, meshes and their measures"+version.workspace = true+edition.workspace = true+license.workspace = true++[lints]+workspace = true++[dependencies]+serde = { workspace = true }++[dev-dependencies]+serde_json = { workspace = true }diff --git a/crates/geom/src/lib.rs b/crates/geom/src/lib.rsnew file mode 100644index 0000000000..55c05ffde3--- /dev/null+++ b/crates/geom/src/lib.rs@@ -0,0 +1,30 @@+//! Geometry foundation for SolveCraft: 2D/3D vectors, sketch planes, axis-aligned boxes and+//! triangle meshes with their measures (volume, area, centroid). Units are millimetres.+//!+//! This crate has no knowledge of sketches, documents or the B-rep kernel; every other crate+//! builds on it.+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]+#![forbid(unsafe_code)]++mod mesh;+mod plane;+mod profile;+mod vec;++pub use mesh::{Aabb3, Mesh, MeshMeasure};+pub use plane::Plane;+pub use profile::{Loop2, Region2, Seg2};+pub use vec::{Vec2, Vec3};++/// Geometric tolerance for coincidence tests (mm).+pub const EPS: f64 = 1e-9;+/// Linear tolerance used for "same point" decisions in modelling (mm).+pub const LINEAR_TOL: f64 = 1e-6;++/// `x` if finite, else `fallback`.+pub fn finite_or(x: f64, fallback: f64) -> f64 {+ if x.is_finite() { x } else { fallback }+}++#[cfg(test)]+mod tests;diff --git a/crates/geom/src/mesh.rs b/crates/geom/src/mesh.rsnew file mode 100644index 0000000000..33dcc5aa28--- /dev/null+++ b/crates/geom/src/mesh.rs@@ -0,0 +1,141 @@+use serde::{Deserialize, Serialize};++use crate::Vec3;++/// Axis-aligned bounding box.+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+pub struct Aabb3 {+ pub min: Vec3,+ pub max: Vec3,+}++impl Default for Aabb3 {+ fn default() -> Self {+ Aabb3::EMPTY+ }+}++impl Aabb3 {+ pub const EMPTY: Aabb3 = Aabb3 {+ min: Vec3::new(f64::INFINITY, f64::INFINITY, f64::INFINITY),+ max: Vec3::new(f64::NEG_INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY),+ };+ pub fn is_empty(&self) -> bool {+ !(self.min.x <= self.max.x && self.min.y <= self.max.y && self.min.z <= self.max.z)+ }+ pub fn add(&mut self, p: Vec3) {+ if p.is_finite() {+ self.min = self.min.min(p);+ self.max = self.max.max(p);+ }+ }+ pub fn union(&self, o: &Aabb3) -> Aabb3 {+ if self.is_empty() {+ return *o;+ }+ if o.is_empty() {+ return *self;+ }+ Aabb3 { min: self.min.min(o.min), max: self.max.max(o.max) }+ }+ pub fn center(&self) -> Vec3 {+ if self.is_empty() { Vec3::ZERO } else { (self.min + self.max) * 0.5 }+ }+ pub fn size(&self) -> Vec3 {+ if self.is_empty() { Vec3::ZERO } else { self.max - self.min }+ }+ pub fn diagonal(&self) -> f64 {+ self.size().len()+ }+}++/// An indexed triangle mesh with per-vertex normals, a face id per triangle (the B-rep face it+/// came from) and edge polylines (the B-rep edges, for display and picking).+#[derive(Clone, Debug, Default, Serialize, Deserialize)]+pub struct Mesh {+ pub positions: Vec<Vec3>,+ pub normals: Vec<Vec3>,+ /// Triangles as vertex index triples (counter-clockwise seen from outside).+ pub triangles: Vec<[u32; 3]>,+ /// B-rep face index per triangle.+ pub tri_face: Vec<u32>,+ /// B-rep edges as polylines.+ pub edges: Vec<Vec<Vec3>>,+}++/// Mass properties of a closed mesh.+#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]+pub struct MeshMeasure {+ pub volume: f64,+ pub area: f64,+ pub centroid: Vec3,+}++impl Mesh {+ pub fn tri(&self, t: &[u32; 3]) -> Option<[Vec3; 3]> {+ Some([*self.positions.get(t[0] as usize)?, *self.positions.get(t[1] as usize)?, *self.positions.get(t[2] as usize)?])+ }++ pub fn bounds(&self) -> Aabb3 {+ let mut b = Aabb3::EMPTY;+ for p in &self.positions {+ b.add(*p);+ }+ b+ }++ /// Signed volume (divergence theorem), surface area and volume centroid.+ pub fn measure(&self) -> MeshMeasure {+ let (mut v6, mut area, mut c) = (0.0, 0.0, Vec3::ZERO);+ for t in &self.triangles {+ let Some([a, b, cc]) = self.tri(t) else { continue };+ let d = a.dot(b.cross(cc));+ v6 += d;+ c += (a + b + cc) * d;+ area += (b - a).cross(cc - a).len() * 0.5;+ }+ let volume = v6 / 6.0;+ let centroid = if v6.abs() > 1e-12 { c / (4.0 * v6) } else { self.bounds().center() };+ MeshMeasure { volume, area, centroid }+ }++ /// Append another mesh (face ids offset by `face_offset`).+ pub fn append(&mut self, o: &Mesh, face_offset: u32) {+ let base = u32::try_from(self.positions.len()).unwrap_or(u32::MAX);+ self.positions.extend_from_slice(&o.positions);+ self.normals.extend_from_slice(&o.normals);+ self.triangles.extend(o.triangles.iter().map(|t| [t[0].saturating_add(base), t[1].saturating_add(base), t[2].saturating_add(base)]));+ self.tri_face.extend(o.tri_face.iter().map(|f| f.saturating_add(face_offset)));+ self.edges.extend(o.edges.iter().cloned());+ }++ /// Closest intersection of a ray with the mesh: (distance along `dir`, triangle index).+ pub fn raycast(&self, o: Vec3, dir: Vec3) -> Option<(f64, usize)> {+ let mut best: Option<(f64, usize)> = None;+ for (i, t) in self.triangles.iter().enumerate() {+ let Some([a, b, c]) = self.tri(t) else { continue };+ let (e1, e2) = (b - a, c - a);+ let p = dir.cross(e2);+ let det = e1.dot(p);+ if det.abs() < 1e-14 {+ continue;+ }+ let inv = 1.0 / det;+ let s = o - a;+ let u = s.dot(p) * inv;+ if !(0.0..=1.0).contains(&u) {+ continue;+ }+ let q = s.cross(e1);+ let v = dir.dot(q) * inv;+ if v < 0.0 || u + v > 1.0 {+ continue;+ }+ let t = e2.dot(q) * inv;+ if t > 1e-9 && best.is_none_or(|(bt, _)| t < bt) {+ best = Some((t, i));+ }+ }+ best+ }+}diff --git a/crates/geom/src/plane.rs b/crates/geom/src/plane.rsnew file mode 100644index 0000000000..d644e3907e--- /dev/null+++ b/crates/geom/src/plane.rs@@ -0,0 +1,83 @@+use serde::{Deserialize, Serialize};++use crate::{Vec2, Vec3};++/// A sketch plane: an origin and two orthonormal in-plane axes. The normal is `x × y`.+///+/// World point of sketch point `(u, v)` = `origin + u·x + v·y`.+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+pub struct Plane {+ pub origin: Vec3,+ #[serde(rename = "x_dir")]+ pub x: Vec3,+ #[serde(rename = "y_dir")]+ pub y: Vec3,+}++impl Plane {+ /// Top: sketch x = +X, y = +Y, normal +Z.+ pub const XY: Plane = Plane { origin: Vec3::ZERO, x: Vec3::X, y: Vec3::Y };+ /// Front: sketch x = +X, y = +Z, normal −Y.+ pub const XZ: Plane = Plane { origin: Vec3::ZERO, x: Vec3::X, y: Vec3::Z };+ /// Right: sketch x = +Y, y = +Z, normal +X.+ pub const YZ: Plane = Plane { origin: Vec3::ZERO, x: Vec3::Y, y: Vec3::Z };++ /// Plane through `origin` with the given axes, re-orthonormalised. `None` if degenerate.+ pub fn new(origin: Vec3, x: Vec3, y: Vec3) -> Option<Plane> {+ let x = x.normalized()?;+ let n = x.cross(y).normalized()?;+ let y = n.cross(x).normalized()?;+ origin.is_finite().then_some(Plane { origin, x, y })+ }++ /// Plane through `origin` with normal `n` (in-plane axes chosen deterministically).+ pub fn from_normal(origin: Vec3, n: Vec3) -> Option<Plane> {+ let n = n.normalized()?;+ // Horizontal planes keep world X as sketch x; others use the horizontal direction Z × n.+ let cand = if n.dot(Vec3::Z).abs() > 0.9 { Vec3::X } else { Vec3::Z.cross(n) };+ let x = (cand - n * cand.dot(n)).normalized()?;+ Plane::new(origin, x, n.cross(x))+ }++ /// Named origin plane: `XY`, `XZ`, `YZ` (case-insensitive).+ pub fn named(name: &str) -> Option<Plane> {+ match name.to_ascii_uppercase().as_str() {+ "XY" | "TOP" => Some(Plane::XY),+ "XZ" | "FRONT" => Some(Plane::XZ),+ "YZ" | "RIGHT" => Some(Plane::YZ),+ _ => None,+ }+ }++ pub fn normal(&self) -> Vec3 {+ self.x.cross(self.y)+ }+ pub fn to_world(&self, p: Vec2) -> Vec3 {+ self.origin + self.x * p.x + self.y * p.y+ }+ pub fn dir_to_world(&self, d: Vec2) -> Vec3 {+ self.x * d.x + self.y * d.y+ }+ pub fn to_local(&self, p: Vec3) -> Vec2 {+ let d = p - self.origin;+ Vec2::new(d.dot(self.x), d.dot(self.y))+ }+ /// Signed distance of `p` above the plane (along the normal).+ pub fn height(&self, p: Vec3) -> f64 {+ (p - self.origin).dot(self.normal())+ }+ /// The plane moved along its normal by `d`.+ pub fn offset(&self, d: f64) -> Plane {+ Plane { origin: self.origin + self.normal() * d, ..*self }+ }+ /// Intersection of the ray `o + t·dir` with the plane (t may be negative).+ pub fn intersect_ray(&self, o: Vec3, dir: Vec3) -> Option<Vec3> {+ let n = self.normal();+ let den = dir.dot(n);+ if den.abs() < 1e-12 {+ return None;+ }+ let t = (self.origin - o).dot(n) / den;+ t.is_finite().then(|| o + dir * t)+ }+}diff --git a/crates/geom/src/profile.rs b/crates/geom/src/profile.rsnew file mode 100644index 0000000000..0b42cf0945--- /dev/null+++ b/crates/geom/src/profile.rs@@ -0,0 +1,263 @@+//! Planar profiles: closed loops of lines and circular arcs, and regions (an outer loop minus+//! holes). Sketches produce them; the kernel turns them into faces.++use std::f64::consts::TAU;++use serde::{Deserialize, Serialize};++use crate::Vec2;++/// One boundary segment in sketch coordinates.+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+#[serde(tag = "type", rename_all = "snake_case")]+pub enum Seg2 {+ Line {+ a: Vec2,+ b: Vec2,+ },+ /// Arc from `start` angle sweeping `sweep` radians (positive = counter-clockwise).+ Arc {+ center: Vec2,+ radius: f64,+ start: f64,+ sweep: f64,+ },+}++impl Seg2 {+ pub fn start(&self) -> Vec2 {+ match *self {+ Seg2::Line { a, .. } => a,+ Seg2::Arc { center, radius, start, .. } => center + Vec2::from_angle(start) * radius,+ }+ }+ pub fn end(&self) -> Vec2 {+ match *self {+ Seg2::Line { b, .. } => b,+ Seg2::Arc { center, radius, start, sweep } => center + Vec2::from_angle(start + sweep) * radius,+ }+ }+ pub fn point_at(&self, t: f64) -> Vec2 {+ match *self {+ Seg2::Line { a, b } => a.lerp(b, t),+ Seg2::Arc { center, radius, start, sweep } => center + Vec2::from_angle(start + sweep * t) * radius,+ }+ }+ pub fn mid(&self) -> Vec2 {+ self.point_at(0.5)+ }+ /// Unit tangent at the start (direction of travel).+ pub fn start_tangent(&self) -> Vec2 {+ match *self {+ Seg2::Line { a, b } => (b - a).normalized().unwrap_or(Vec2::X),+ Seg2::Arc { start, sweep, .. } => Vec2::from_angle(start).perp() * sweep.signum(),+ }+ }+ /// Unit tangent at the end (direction of travel).+ pub fn end_tangent(&self) -> Vec2 {+ match *self {+ Seg2::Line { a, b } => (b - a).normalized().unwrap_or(Vec2::X),+ Seg2::Arc { start, sweep, .. } => Vec2::from_angle(start + sweep).perp() * sweep.signum(),+ }+ }+ pub fn reversed(&self) -> Seg2 {+ match *self {+ Seg2::Line { a, b } => Seg2::Line { a: b, b: a },+ Seg2::Arc { center, radius, start, sweep } => Seg2::Arc { center, radius, start: start + sweep, sweep: -sweep },+ }+ }+ pub fn length(&self) -> f64 {+ match *self {+ Seg2::Line { a, b } => a.dist(b),+ Seg2::Arc { radius, sweep, .. } => (radius * sweep).abs(),+ }+ }+ /// Contribution to the loop's signed area (shoelace integral ½∮(x dy − y dx)).+ pub fn area_term(&self) -> f64 {+ match *self {+ Seg2::Line { a, b } => 0.5 * a.cross(b),+ Seg2::Arc { radius, sweep, .. } => {+ let (a, b) = (self.start(), self.end());+ // Chord term plus the circular segment between chord and arc.+ 0.5 * a.cross(b) + 0.5 * radius * radius * (sweep - sweep.sin())+ }+ }+ }+ /// Polyline approximation (including both end points) with at most `tol` chord error.+ pub fn polyline(&self, tol: f64) -> Vec<Vec2> {+ match *self {+ Seg2::Line { a, b } => vec![a, b],+ Seg2::Arc { radius, sweep, .. } => {+ let tol = tol.max(radius.abs() * 1e-6).max(1e-9);+ let step = if tol < radius { 2.0 * (1.0 - tol / radius).clamp(-1.0, 1.0).acos() } else { TAU / 8.0 };+ let n = ((sweep.abs() / step.max(1e-6)).ceil() as usize).clamp(2, 4096);+ (0..=n).map(|i| self.point_at(i as f64 / n as f64)).collect()+ }+ }+ }+}++/// A closed loop of segments, each starting where the previous one ends.+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]+pub struct Loop2 {+ pub segs: Vec<Seg2>,+}++impl Loop2 {+ /// Full circle as two half arcs (counter-clockwise).+ pub fn circle(center: Vec2, radius: f64) -> Loop2 {+ Loop2 {+ segs: vec![+ Seg2::Arc { center, radius, start: 0.0, sweep: std::f64::consts::PI },+ Seg2::Arc { center, radius, start: std::f64::consts::PI, sweep: std::f64::consts::PI },+ ],+ }+ }+ pub fn polygon(pts: &[Vec2]) -> Loop2 {+ let n = pts.len();+ Loop2 { segs: (0..n).filter_map(|i| Some(Seg2::Line { a: *pts.get(i)?, b: *pts.get((i + 1) % n)? })).collect() }+ }+ /// Signed area: positive when counter-clockwise.+ pub fn signed_area(&self) -> f64 {+ self.segs.iter().map(Seg2::area_term).sum()+ }+ pub fn reversed(&self) -> Loop2 {+ Loop2 { segs: self.segs.iter().rev().map(Seg2::reversed).collect() }+ }+ /// Counter-clockwise copy.+ pub fn ccw(&self) -> Loop2 {+ if self.signed_area() < 0.0 { self.reversed() } else { self.clone() }+ }+ pub fn polyline(&self, tol: f64) -> Vec<Vec2> {+ let mut out = Vec::new();+ for s in &self.segs {+ let p = s.polyline(tol);+ out.extend(p.iter().take(p.len().saturating_sub(1)));+ }+ out+ }+ /// Even-odd point containment against the polyline approximation.+ pub fn contains(&self, p: Vec2) -> bool {+ let poly = self.polyline(1e-3);+ let n = poly.len();+ let mut inside = false;+ for i in 0..n {+ let (Some(a), Some(b)) = (poly.get(i), poly.get((i + 1) % n)) else { continue };+ if (a.y > p.y) != (b.y > p.y) {+ let x = a.x + (p.y - a.y) / (b.y - a.y) * (b.x - a.x);+ if p.x < x {+ inside = !inside;+ }+ }+ }+ inside+ }+ /// Area-weighted centroid (of the polyline approximation).+ pub fn centroid(&self) -> Vec2 {+ let poly = self.polyline(1e-3);+ let n = poly.len();+ let (mut a2, mut c) = (0.0, Vec2::ZERO);+ for i in 0..n {+ let (Some(p), Some(q)) = (poly.get(i), poly.get((i + 1) % n)) else { continue };+ let k = p.cross(*q);+ a2 += k;+ c += (*p + *q) * k;+ }+ if a2.abs() < 1e-15 { poly.first().copied().unwrap_or_default() } else { c / (3.0 * a2) }+ }+ /// Closed within `tol`?+ pub fn is_closed(&self, tol: f64) -> bool {+ let n = self.segs.len();+ n > 0+ && (0..n).all(|i| match (self.segs.get(i), self.segs.get((i + 1) % n)) {+ (Some(a), Some(b)) => a.end().dist(b.start()) <= tol,+ _ => false,+ })+ }+}++/// A planar region: outer loop (counter-clockwise) minus holes (clockwise).+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]+pub struct Region2 {+ pub outer: Loop2,+ pub holes: Vec<Loop2>,+}++impl Region2 {+ pub fn area(&self) -> f64 {+ self.outer.signed_area().abs() - self.holes.iter().map(|h| h.signed_area().abs()).sum::<f64>()+ }+ /// A point strictly inside the region (for picking and labels).+ pub fn interior_point(&self) -> Vec2 {+ let c = self.centroid();+ if self.contains(c) {+ return c;+ }+ // Scan a few horizontal lines for the midpoint of the widest inside span.+ let poly = self.outer.polyline(1e-2);+ let (mut y0, mut y1) = (f64::INFINITY, f64::NEG_INFINITY);+ for p in &poly {+ y0 = y0.min(p.y);+ y1 = y1.max(p.y);+ }+ for k in 1..16 {+ let y = y0 + (y1 - y0) * k as f64 / 16.0;+ let mut xs: Vec<f64> = Vec::new();+ for l in std::iter::once(&self.outer).chain(&self.holes) {+ let pl = l.polyline(1e-2);+ let n = pl.len();+ for i in 0..n {+ let (Some(a), Some(b)) = (pl.get(i), pl.get((i + 1) % n)) else { continue };+ if (a.y > y) != (b.y > y) {+ xs.push(a.x + (y - a.y) / (b.y - a.y) * (b.x - a.x));+ }+ }+ }+ xs.sort_by(f64::total_cmp);+ for w in xs.chunks(2) {+ if let [a, b] = w {+ let p = Vec2::new((a + b) * 0.5, y);+ if self.contains(p) {+ return p;+ }+ }+ }+ }+ c+ }+ pub fn contains(&self, p: Vec2) -> bool {+ self.outer.contains(p) && !self.holes.iter().any(|h| h.contains(p))+ }+ pub fn centroid(&self) -> Vec2 {+ let ao = self.outer.signed_area().abs();+ let mut c = self.outer.centroid() * ao;+ let mut a = ao;+ for h in &self.holes {+ let ah = h.signed_area().abs();+ c -= h.centroid() * ah;+ a -= ah;+ }+ if a.abs() < 1e-15 { self.outer.centroid() } else { c / a }+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn areas() {+ let sq = Loop2::polygon(&[Vec2::new(0.0, 0.0), Vec2::new(4.0, 0.0), Vec2::new(4.0, 3.0), Vec2::new(0.0, 3.0)]);+ assert!((sq.signed_area() - 12.0).abs() < 1e-12);+ assert!((sq.reversed().signed_area() + 12.0).abs() < 1e-12);+ let c = Loop2::circle(Vec2::new(5.0, 5.0), 2.0);+ assert!((c.signed_area() - std::f64::consts::PI * 4.0).abs() < 1e-9);+ assert!(c.is_closed(1e-9));+ let r = Region2 { outer: Loop2::circle(Vec2::ZERO, 10.0), holes: vec![Loop2::circle(Vec2::ZERO, 5.0).reversed()] };+ assert!((r.area() - std::f64::consts::PI * 75.0).abs() < 1e-9);+ let ip = r.interior_point();+ assert!(r.contains(ip), "{ip:?}");+ assert!(sq.contains(Vec2::new(1.0, 1.0)) && !sq.contains(Vec2::new(5.0, 1.0)));+ assert!(sq.centroid().dist(Vec2::new(2.0, 1.5)) < 1e-9);+ }+}diff --git a/crates/geom/src/tests.rs b/crates/geom/src/tests.rsnew file mode 100644index 0000000000..8fcf4c7508--- /dev/null+++ b/crates/geom/src/tests.rs@@ -0,0 +1,64 @@+use crate::*;++fn cube_mesh(s: f64) -> Mesh {+ let p = |x: f64, y: f64, z: f64| Vec3::new(x * s, y * s, z * s);+ let positions = vec![p(0., 0., 0.), p(1., 0., 0.), p(1., 1., 0.), p(0., 1., 0.), p(0., 0., 1.), p(1., 0., 1.), p(1., 1., 1.), p(0., 1., 1.)];+ let triangles =+ vec![[0, 2, 1], [0, 3, 2], [4, 5, 6], [4, 6, 7], [0, 1, 5], [0, 5, 4], [1, 2, 6], [1, 6, 5], [2, 3, 7], [2, 7, 6], [3, 0, 4], [3, 4, 7]];+ let n = triangles.len();+ Mesh { normals: vec![Vec3::Z; 8], positions, triangles, tri_face: vec![0; n], edges: vec![] }+}++#[test]+fn cube_measure() {+ let m = cube_mesh(2.0).measure();+ assert!((m.volume - 8.0).abs() < 1e-12);+ assert!((m.area - 24.0).abs() < 1e-12);+ assert!(m.centroid.dist(Vec3::new(1.0, 1.0, 1.0)) < 1e-12);+}++#[test]+fn raycast_hits_front_face() {+ let m = cube_mesh(2.0);+ let (t, _) = m.raycast(Vec3::new(1.0, 1.0, 10.0), Vec3::new(0.0, 0.0, -1.0)).unwrap();+ assert!((t - 8.0).abs() < 1e-9);+ assert!(m.raycast(Vec3::new(5.0, 5.0, 10.0), Vec3::new(0.0, 0.0, -1.0)).is_none());+}++#[test]+fn planes() {+ assert_eq!(Plane::XY.normal(), Vec3::Z);+ assert_eq!(Plane::XZ.normal(), Vec3::new(0.0, -1.0, 0.0));+ assert_eq!(Plane::YZ.normal(), Vec3::X);+ let p = Plane::XZ.to_world(Vec2::new(3.0, 4.0));+ assert_eq!(p, Vec3::new(3.0, 0.0, 4.0));+ assert_eq!(Plane::XZ.to_local(p), Vec2::new(3.0, 4.0));+ let hit = Plane::XY.offset(5.0).intersect_ray(Vec3::new(1.0, 2.0, 10.0), Vec3::new(0.0, 0.0, -2.0)).unwrap();+ assert!(hit.dist(Vec3::new(1.0, 2.0, 5.0)) < 1e-12);+ assert!(Plane::new(Vec3::ZERO, Vec3::X, Vec3::X).is_none());+ let f = Plane::from_normal(Vec3::ZERO, Vec3::new(0.0, 0.0, 3.0)).unwrap();+ assert!((f.normal() - Vec3::Z).len() < 1e-12);+ assert!(Plane::from_normal(Vec3::ZERO, Vec3::new(f64::NAN, 0.0, 1.0)).is_none());+}++#[test]+fn vec_ops_and_serde() {+ let a = Vec3::new(1.0, 2.0, 3.0);+ assert_eq!(a.cross(Vec3::X), Vec3::new(0.0, 3.0, -2.0));+ assert_eq!(Vec2::new(3.0, 4.0).len(), 5.0);+ assert!(Vec2::ZERO.normalized().is_none());+ assert!(Vec3::new(0.5, 0.0, 0.0).dist_to_segment(Vec3::ZERO, Vec3::X) < 1e-12);+ assert_eq!(serde_json::to_string(&a).unwrap(), "[1.0,2.0,3.0]");+ let b: Vec2 = serde_json::from_str("[1,2]").unwrap();+ assert_eq!(b, Vec2::new(1.0, 2.0));+}++#[test]+fn aabb() {+ let mut b = Aabb3::EMPTY;+ assert!(b.is_empty());+ b.add(Vec3::new(1.0, 2.0, 3.0));+ b.add(Vec3::new(f64::NAN, 0.0, 0.0));+ b.add(Vec3::new(-1.0, 0.0, 0.0));+ assert_eq!(b.size(), Vec3::new(2.0, 2.0, 3.0));+}diff --git a/crates/geom/src/vec.rs b/crates/geom/src/vec.rsnew file mode 100644index 0000000000..d18127b553--- /dev/null+++ b/crates/geom/src/vec.rs@@ -0,0 +1,159 @@+use std::ops::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign};++use serde::{Deserialize, Serialize};++/// 2D vector / point (sketch space).+#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]+#[serde(from = "[f64; 2]", into = "[f64; 2]")]+pub struct Vec2 {+ pub x: f64,+ pub y: f64,+}++/// 3D vector / point (model space, Z up).+#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]+#[serde(from = "[f64; 3]", into = "[f64; 3]")]+pub struct Vec3 {+ pub x: f64,+ pub y: f64,+ pub z: f64,+}++impl From<[f64; 2]> for Vec2 {+ fn from(a: [f64; 2]) -> Self {+ Vec2::new(a[0], a[1])+ }+}+impl From<Vec2> for [f64; 2] {+ fn from(v: Vec2) -> Self {+ [v.x, v.y]+ }+}+impl From<[f64; 3]> for Vec3 {+ fn from(a: [f64; 3]) -> Self {+ Vec3::new(a[0], a[1], a[2])+ }+}+impl From<Vec3> for [f64; 3] {+ fn from(v: Vec3) -> Self {+ [v.x, v.y, v.z]+ }+}++impl Vec2 {+ pub const ZERO: Vec2 = Vec2 { x: 0.0, y: 0.0 };+ pub const X: Vec2 = Vec2 { x: 1.0, y: 0.0 };+ pub const Y: Vec2 = Vec2 { x: 0.0, y: 1.0 };+ pub const fn new(x: f64, y: f64) -> Self {+ Vec2 { x, y }+ }+ pub fn dot(self, o: Vec2) -> f64 {+ self.x * o.x + self.y * o.y+ }+ /// z component of the 3D cross product.+ pub fn cross(self, o: Vec2) -> f64 {+ self.x * o.y - self.y * o.x+ }+ pub fn len(self) -> f64 {+ self.x.hypot(self.y)+ }+ pub fn len2(self) -> f64 {+ self.dot(self)+ }+ pub fn dist(self, o: Vec2) -> f64 {+ (self - o).len()+ }+ pub fn normalized(self) -> Option<Vec2> {+ let l = self.len();+ (l > crate::EPS && l.is_finite()).then(|| self / l)+ }+ /// Rotated +90°.+ pub fn perp(self) -> Vec2 {+ Vec2::new(-self.y, self.x)+ }+ pub fn angle(self) -> f64 {+ self.y.atan2(self.x)+ }+ pub fn from_angle(a: f64) -> Vec2 {+ Vec2::new(a.cos(), a.sin())+ }+ pub fn lerp(self, o: Vec2, t: f64) -> Vec2 {+ self + (o - self) * t+ }+ pub fn is_finite(self) -> bool {+ self.x.is_finite() && self.y.is_finite()+ }+ pub fn extend(self, z: f64) -> Vec3 {+ Vec3::new(self.x, self.y, z)+ }+}++impl Vec3 {+ pub const ZERO: Vec3 = Vec3 { x: 0.0, y: 0.0, z: 0.0 };+ pub const X: Vec3 = Vec3 { x: 1.0, y: 0.0, z: 0.0 };+ pub const Y: Vec3 = Vec3 { x: 0.0, y: 1.0, z: 0.0 };+ pub const Z: Vec3 = Vec3 { x: 0.0, y: 0.0, z: 1.0 };+ pub const fn new(x: f64, y: f64, z: f64) -> Self {+ Vec3 { x, y, z }+ }+ pub fn dot(self, o: Vec3) -> f64 {+ self.x * o.x + self.y * o.y + self.z * o.z+ }+ pub fn cross(self, o: Vec3) -> Vec3 {+ Vec3::new(self.y * o.z - self.z * o.y, self.z * o.x - self.x * o.z, self.x * o.y - self.y * o.x)+ }+ pub fn len(self) -> f64 {+ self.len2().sqrt()+ }+ pub fn len2(self) -> f64 {+ self.dot(self)+ }+ pub fn dist(self, o: Vec3) -> f64 {+ (self - o).len()+ }+ pub fn normalized(self) -> Option<Vec3> {+ let l = self.len();+ (l > crate::EPS && l.is_finite()).then(|| self / l)+ }+ pub fn lerp(self, o: Vec3, t: f64) -> Vec3 {+ self + (o - self) * t+ }+ pub fn is_finite(self) -> bool {+ self.x.is_finite() && self.y.is_finite() && self.z.is_finite()+ }+ pub fn min(self, o: Vec3) -> Vec3 {+ Vec3::new(self.x.min(o.x), self.y.min(o.y), self.z.min(o.z))+ }+ pub fn max(self, o: Vec3) -> Vec3 {+ Vec3::new(self.x.max(o.x), self.y.max(o.y), self.z.max(o.z))+ }+ /// Any unit vector perpendicular to `self` (which should be non-zero).+ pub fn any_perp(self) -> Vec3 {+ let a = if self.x.abs() < 0.9 { Vec3::X } else { Vec3::Y };+ self.cross(a).normalized().unwrap_or(Vec3::Z)+ }+ pub fn to_f32(self) -> [f32; 3] {+ [self.x as f32, self.y as f32, self.z as f32]+ }+ /// Distance from this point to the segment `a`–`b`.+ pub fn dist_to_segment(self, a: Vec3, b: Vec3) -> f64 {+ let ab = b - a;+ let l2 = ab.len2();+ let t = if l2 > 0.0 { ((self - a).dot(ab) / l2).clamp(0.0, 1.0) } else { 0.0 };+ self.dist(a + ab * t)+ }+}++macro_rules! ops {+ ($t:ident, $($f:ident),+) => {+ impl Add for $t { type Output = $t; fn add(self, o: $t) -> $t { $t { $($f: self.$f + o.$f),+ } } }+ impl Sub for $t { type Output = $t; fn sub(self, o: $t) -> $t { $t { $($f: self.$f - o.$f),+ } } }+ impl Mul<f64> for $t { type Output = $t; fn mul(self, k: f64) -> $t { $t { $($f: self.$f * k),+ } } }+ impl Div<f64> for $t { type Output = $t; fn div(self, k: f64) -> $t { $t { $($f: self.$f / k),+ } } }+ impl Neg for $t { type Output = $t; fn neg(self) -> $t { $t { $($f: -self.$f),+ } } }+ impl AddAssign for $t { fn add_assign(&mut self, o: $t) { $(self.$f += o.$f;)+ } }+ impl SubAssign for $t { fn sub_assign(&mut self, o: $t) { $(self.$f -= o.$f;)+ } }+ };+}+ops!(Vec2, x, y);+ops!(Vec3, x, y, z);diff --git a/crates/io/Cargo.toml b/crates/io/Cargo.tomlnew file mode 100644index 0000000000..f8b045bf53--- /dev/null+++ b/crates/io/Cargo.toml@@ -0,0 +1,8 @@+[package]+name = "solvecraft-io"+version.workspace = true+edition.workspace = true+license.workspace = true++[lints]+workspace = truediff --git a/crates/io/src/lib.rs b/crates/io/src/lib.rsnew file mode 100644index 0000000000..8b13789179--- /dev/null+++ b/crates/io/src/lib.rs@@ -0,0 +1 @@+diff --git a/crates/kernel/Cargo.toml b/crates/kernel/Cargo.tomlnew file mode 100644index 0000000000..da244fd13f--- /dev/null+++ b/crates/kernel/Cargo.toml@@ -0,0 +1,19 @@+[package]+name = "solvecraft-kernel"+description = "SolveCraft B-rep kernel boundary: solids, extrude/revolve/booleans/fillets, tessellation, measures and STEP, behind our own API"+version.workspace = true+edition.workspace = true+license.workspace = true++[lints]+workspace = true++[dependencies]+solvecraft-geom = { workspace = true }+serde = { workspace = true }+thiserror = { workspace = true }+log = { workspace = true }+monstertruck-modeling = { workspace = true }+monstertruck-solid = { workspace = true }+monstertruck-meshing = { workspace = true }+monstertruck-io = { workspace = true }diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rsnew file mode 100644index 0000000000..835d723b63--- /dev/null+++ b/crates/kernel/src/body.rs@@ -0,0 +1,232 @@+use monstertruck_meshing::prelude::*;+use monstertruck_modeling as mt;+use serde::Serialize;+use solvecraft_geom::{Mesh, Vec3};++use crate::{KernelError, Result, guard};++pub(crate) type Solid = mt::Solid;++/// A solid body (one or more closed shells). Cheap to clone; never mutated in place.+#[derive(Clone, Debug)]+pub struct Body {+ pub(crate) solid: std::sync::Arc<Solid>,+}++/// A B-rep edge as seen by the rest of the application.+#[derive(Clone, Debug, Serialize)]+pub struct EdgeInfo {+ pub index: usize,+ /// Polyline approximation.+ pub points: Vec<Vec3>,+ /// Point halfway along the polyline (used to re-find the edge).+ pub mid: Vec3,+ pub length: f64,+}++/// A B-rep face.+#[derive(Clone, Debug, Serialize)]+pub struct FaceInfo {+ pub index: usize,+ pub area: f64,+ pub centroid: Vec3,+ /// Unit normal if the face is planar.+ pub plane_normal: Option<Vec3>,+}++pub(crate) fn p3(v: Vec3) -> mt::Point3 {+ mt::Point3::new(v.x, v.y, v.z)+}+pub(crate) fn v3(v: Vec3) -> mt::Vector3 {+ mt::Vector3::new(v.x, v.y, v.z)+}+pub(crate) fn from_p3(p: mt::Point3) -> Vec3 {+ Vec3::new(p.x, p.y, p.z)+}++fn polyline_mid(pts: &[Vec3]) -> (Vec3, f64) {+ let len: f64 = pts.windows(2).map(|w| w.first().zip(w.get(1)).map(|(a, b)| a.dist(*b)).unwrap_or(0.0)).sum();+ let mut acc = 0.0;+ for w in pts.windows(2) {+ if let (Some(a), Some(b)) = (w.first(), w.get(1)) {+ let l = a.dist(*b);+ if acc + l >= len * 0.5 && l > 0.0 {+ return (a.lerp(*b, (len * 0.5 - acc) / l), len);+ }+ acc += l;+ }+ }+ (pts.first().copied().unwrap_or_default(), len)+}++impl Body {+ pub(crate) fn new(mut solid: Solid) -> Result<Body> {+ if solid.is_empty() {+ return Err(KernelError::Failed("empty result".into()));+ }+ // Orient outward: a closed solid must have positive volume.+ let v = guard("orient", || Ok(solid.triangulation(1.0).to_polygon().volume()))?;+ if v < 0.0 {+ solid.not();+ }+ Ok(Body { solid: std::sync::Arc::new(solid) })+ }++ /// A deep copy of the solid that can be mutated without affecting other bodies.+ pub(crate) fn deep_copy(&self) -> Solid {+ mt::builder::clone(&*self.solid)+ }++ /// Characteristic size (bounding box diagonal) for tolerances.+ pub fn size(&self) -> f64 {+ let mut b = solvecraft_geom::Aabb3::EMPTY;+ for v in self.solid.vertex_iter() {+ b.add(from_p3(v.point()));+ }+ let d = b.diagonal();+ if d.is_finite() && d > 0.0 { d } else { 1.0 }+ }++ /// Distinct edges in a stable order (the order of `edges()` and `tessellate().edges`).+ pub(crate) fn unique_edges(solid: &Solid) -> Vec<mt::Edge> {+ let mut seen = std::collections::HashSet::new();+ solid.edge_iter().filter(|e| seen.insert(e.id())).collect()+ }++ /// Triangulate with chord tolerance `tol` (mm). Triangles carry their face index.+ pub fn tessellate(&self, tol: f64) -> Result<Mesh> {+ let tol = if tol.is_finite() && tol > 0.0 { tol } else { 0.05 };+ let tol = tol.max(self.size() * 1e-6);+ guard("tessellate", || {+ let meshed = self.solid.triangulation(tol);+ let mut out = Mesh::default();+ for (fi, face) in meshed.face_iter().enumerate() {+ let Some(pm) = face.surface() else { continue };+ let flip = !face.orientation();+ let base = u32::try_from(out.positions.len()).unwrap_or(u32::MAX);+ let pos = pm.positions();+ let nor = pm.normals();+ // Expand to per-corner vertices so normals stay per face (crisp edges).+ for tri in pm.faces().triangle_iter() {+ let mut idx = [0u32; 3];+ for (k, v) in tri.iter().enumerate() {+ let Some(p) = pos.get(v.pos) else { continue };+ let n = v.nor.and_then(|ni| nor.get(ni)).map(|n| Vec3::new(n.x, n.y, n.z)).unwrap_or(Vec3::Z);+ let n = if flip { -n } else { n };+ out.positions.push(Vec3::new(p.x, p.y, p.z));+ out.normals.push(n);+ if let Some(slot) = idx.get_mut(k) {+ *slot = u32::try_from(out.positions.len() - 1).unwrap_or(0);+ }+ }+ let t = if flip { [idx[0], idx[2], idx[1]] } else { idx };+ out.triangles.push(t);+ out.tri_face.push(u32::try_from(fi).unwrap_or(u32::MAX));+ }+ let _ = base;+ }+ // Fill missing normals from geometry.+ for t in &out.triangles {+ let (Some(a), Some(b), Some(c)) =+ (out.positions.get(t[0] as usize), out.positions.get(t[1] as usize), out.positions.get(t[2] as usize))+ else {+ continue;+ };+ let fnrm = (b - a).cross(c - a).normalized().unwrap_or(Vec3::Z);+ for k in t {+ if let Some(n) = out.normals.get_mut(*k as usize)+ && (n.dot(fnrm) < -0.2 || n.len() < 0.5)+ {+ *n = fnrm;+ }+ }+ }+ let mut seen = std::collections::HashSet::new();+ for e in meshed.edge_iter() {+ if !seen.insert(e.id()) {+ continue;+ }+ let c = e.oriented_curve();+ out.edges.push(c.0.iter().map(|p| Vec3::new(p.x, p.y, p.z)).collect());+ }+ Ok(out)+ })+ }++ /// Edges with polylines (index = position in [`Body::tessellate`]'s `edges`).+ pub fn edges(&self, tol: f64) -> Result<Vec<EdgeInfo>> {+ let m = self.tessellate(tol)?;+ Ok(m.edges+ .into_iter()+ .enumerate()+ .map(|(index, points)| {+ let (mid, length) = polyline_mid(&points);+ EdgeInfo { index, points, mid, length }+ })+ .collect())+ }++ /// Faces with area and centroid.+ pub fn faces(&self, tol: f64) -> Result<Vec<FaceInfo>> {+ let m = self.tessellate(tol)?;+ let nf = self.solid.face_iter().count();+ let mut acc: Vec<(f64, Vec3, Vec3, bool)> = vec![(0.0, Vec3::ZERO, Vec3::ZERO, true); nf];+ for (t, f) in m.triangles.iter().zip(&m.tri_face) {+ let Some([a, b, c]) = m.tri(t) else { continue };+ let cr = (b - a).cross(c - a);+ let ar = cr.len() * 0.5;+ if let Some(slot) = acc.get_mut(*f as usize) {+ slot.0 += ar;+ slot.1 += (a + b + c) * (ar / 3.0);+ if let Some(n) = cr.normalized() {+ if slot.2 == Vec3::ZERO {+ slot.2 = n;+ } else if slot.2.dot(n) < 1.0 - 1e-6 {+ slot.3 = false;+ }+ }+ }+ }+ Ok(acc+ .into_iter()+ .enumerate()+ .map(|(index, (area, c, n, planar))| FaceInfo {+ index,+ area,+ centroid: if area > 0.0 { c / area } else { Vec3::ZERO },+ plane_normal: (planar && n != Vec3::ZERO).then_some(n),+ })+ .collect())+ }++ /// Index of the edge closest to `p` (by polyline distance).+ pub fn nearest_edge(&self, p: Vec3, tol: f64) -> Result<Option<(usize, f64)>> {+ let edges = self.edges(tol)?;+ let mut best: Option<(usize, f64)> = None;+ for e in &edges {+ for w in e.points.windows(2) {+ if let (Some(a), Some(b)) = (w.first(), w.get(1)) {+ let d = p.dist_to_segment(*a, *b);+ if best.is_none_or(|(_, bd)| d < bd) {+ best = Some((e.index, d));+ }+ }+ }+ }+ Ok(best)+ }++ pub fn face_count(&self) -> usize {+ self.solid.face_iter().count()+ }+ pub fn edge_count(&self) -> usize {+ Self::unique_edges(&self.solid).len()+ }+ pub fn vertex_count(&self) -> usize {+ let mut seen = std::collections::HashSet::new();+ self.solid.vertex_iter().filter(|v| seen.insert(v.id())).count()+ }+ pub fn shell_count(&self) -> usize {+ self.solid.boundaries().len()+ }+}diff --git a/crates/kernel/src/build.rs b/crates/kernel/src/build.rsnew file mode 100644index 0000000000..d31acc08cb--- /dev/null+++ b/crates/kernel/src/build.rs@@ -0,0 +1,202 @@+//! Building bodies: extrude and revolve planar regions, primitives.++use monstertruck_modeling as mt;+use mt::builder;+use solvecraft_geom::{Loop2, Plane, Region2, Seg2, Vec2, Vec3};++use crate::body::{Body, Solid, p3, v3};+use crate::{KernelError, Result, guard};++const MAX_SEGS: usize = 20_000;++fn finite(x: f64, what: &str) -> Result<f64> {+ if x.is_finite() && x.abs() < 1e7 { Ok(x) } else { Err(KernelError::Invalid(format!("{what} = {x}"))) }+}++/// A closed wire in 3D from a sketch loop.+fn wire(plane: &Plane, lp: &Loop2) -> Result<mt::Wire> {+ let n = lp.segs.len();+ if n == 0 || n > MAX_SEGS {+ return Err(KernelError::Invalid(format!("loop with {n} segments")));+ }+ if !lp.is_closed(1e-6) {+ return Err(KernelError::Invalid("profile loop is not closed".into()));+ }+ let verts: Vec<mt::Vertex> = lp.segs.iter().map(|s| builder::vertex(p3(plane.to_world(s.start())))).collect();+ let mut edges = Vec::with_capacity(n);+ for (i, s) in lp.segs.iter().enumerate() {+ let (Some(a), Some(b)) = (verts.get(i), verts.get((i + 1) % n)) else { continue };+ let e: mt::Edge = match *s {+ Seg2::Line { .. } => builder::line(a, b),+ Seg2::Arc { sweep, .. } => {+ if sweep.abs() < 1e-9 {+ return Err(KernelError::Invalid("zero-length arc".into()));+ }+ // Split big arcs so every piece is well conditioned.+ let mid = plane.to_world(s.mid());+ if sweep.abs() > std::f64::consts::PI * 1.5 {+ let vm = builder::vertex(p3(mid));+ let q1 = plane.to_world(s.point_at(0.25));+ let q3 = plane.to_world(s.point_at(0.75));+ edges.push(+ builder::try_circle_arc(a, &vm, mt::builder::CircularArcConstraint::ThroughPoint(p3(q1)))+ .map_err(|e| KernelError::Invalid(e.to_string()))?,+ );+ builder::try_circle_arc(&vm, b, mt::builder::CircularArcConstraint::ThroughPoint(p3(q3)))+ .map_err(|e| KernelError::Invalid(e.to_string()))?+ } else {+ builder::try_circle_arc(a, b, mt::builder::CircularArcConstraint::ThroughPoint(p3(mid)))+ .map_err(|e| KernelError::Invalid(e.to_string()))?+ }+ }+ };+ edges.push(e);+ }+ Ok(edges.into())+}++/// A planar face from a region (outer loop with holes).+pub(crate) fn face(plane: &Plane, r: &Region2) -> Result<mt::Face> {+ let mut wires = vec![wire(plane, &r.outer.ccw())?];+ for h in &r.holes {+ wires.push(wire(plane, &h.ccw().reversed())?);+ }+ guard("face", || mt::profile::attach_plane_normalized(wires).map_err(|e| KernelError::Invalid(format!("profile: {e}"))))+}++fn region_ok(r: &Region2) -> Result<()> {+ if r.area().abs() < 1e-9 {+ return Err(KernelError::Invalid("profile has no area".into()));+ }+ for s in std::iter::once(&r.outer).chain(&r.holes).flat_map(|l| &l.segs) {+ let ok = match *s {+ Seg2::Line { a, b } => a.is_finite() && b.is_finite(),+ Seg2::Arc { center, radius, start, sweep } => {+ center.is_finite() && radius.is_finite() && radius > 1e-9 && start.is_finite() && sweep.is_finite()+ }+ };+ if !ok {+ return Err(KernelError::Invalid("non-finite profile".into()));+ }+ }+ Ok(())+}++/// Extrude each region from `start` to `end` along the plane normal (offsets in mm, `end > start`).+pub fn extrude(plane: &Plane, regions: &[Region2], start: f64, end: f64) -> Result<Vec<Body>> {+ let (start, end) = (finite(start, "start")?, finite(end, "end")?);+ let (lo, hi) = if end >= start { (start, end) } else { (end, start) };+ if hi - lo < 1e-6 {+ return Err(KernelError::Invalid("extrude distance is zero".into()));+ }+ if regions.is_empty() {+ return Err(KernelError::Invalid("no profile selected".into()));+ }+ let n = plane.normal();+ let mut out = Vec::new();+ for r in regions {+ region_ok(r)?;+ let base = plane.offset(lo);+ let f = face(&base, r)?;+ let solid: Solid = guard("extrude", || Ok(builder::extrude(&f, v3(n * (hi - lo)))))?;+ out.push(Body::new(solid)?);+ }+ Ok(out)+}++/// Revolve each region about the axis through sketch point `axis_origin` with sketch direction+/// `axis_dir` by `angle` radians (|angle| ≥ 2π = full revolution).+pub fn revolve(plane: &Plane, regions: &[Region2], axis_origin: Vec2, axis_dir: Vec2, angle: f64) -> Result<Vec<Body>> {+ let angle = finite(angle, "angle")?;+ if angle.abs() < 1e-6 {+ return Err(KernelError::Invalid("revolve angle is zero".into()));+ }+ let d = axis_dir.normalized().ok_or_else(|| KernelError::Invalid("revolve axis has no direction".into()))?;+ if regions.is_empty() {+ return Err(KernelError::Invalid("no profile selected".into()));+ }+ // The profile must lie on one side of the axis.+ let o = plane.to_world(axis_origin);+ let axis = plane.dir_to_world(d);+ let mut out = Vec::new();+ for r in regions {+ region_ok(r)?;+ let (mut neg, mut pos) = (false, false);+ for p in r.outer.polyline(1e-3) {+ let s = d.cross(p - axis_origin);+ neg |= s < -1e-7;+ pos |= s > 1e-7;+ }+ if neg && pos {+ return Err(KernelError::Invalid("the profile crosses the revolve axis".into()));+ }+ let f = face(plane, r)?;+ let full = angle.abs() >= std::f64::consts::TAU - 1e-9;+ let solid: Solid = guard("revolve", || {+ Ok(if full {+ builder::revolve(&f, p3(o), v3(axis), builder::SweepAngle::Closed, 4)+ } else {+ let div = ((angle.abs() / std::f64::consts::FRAC_PI_2).ceil() as usize).clamp(1, 8);+ builder::revolve(&f, p3(o), v3(axis), builder::SweepAngle::Partial(mt::Rad(angle)), div)+ })+ })?;+ out.push(Body::new(solid)?);+ }+ Ok(out)+}++/// Axis-aligned box between two corners.+pub fn box_solid(a: Vec3, b: Vec3) -> Result<Body> {+ let (lo, hi) = (a.min(b), a.max(b));+ let s = hi - lo;+ if !(s.x > 1e-6 && s.y > 1e-6 && s.z > 1e-6 && s.is_finite() && s.len() < 1e7) {+ return Err(KernelError::Invalid("box needs a positive size in x, y and z".into()));+ }+ let r = Region2 {+ outer: Loop2::polygon(&[Vec2::new(lo.x, lo.y), Vec2::new(hi.x, lo.y), Vec2::new(hi.x, hi.y), Vec2::new(lo.x, hi.y)]),+ holes: vec![],+ };+ let mut v = extrude(&Plane::XY, &[r], lo.z, hi.z)?;+ v.pop().ok_or_else(|| KernelError::Failed("box".into()))+}++/// Cylinder with base centre `base`, axis direction `axis`, radius and height.+pub fn cylinder(base: Vec3, axis: Vec3, radius: f64, height: f64) -> Result<Body> {+ let plane = Plane::from_normal(base, axis).ok_or_else(|| KernelError::Invalid("cylinder axis".into()))?;+ let radius = finite(radius, "radius")?;+ if radius <= 1e-6 {+ return Err(KernelError::Invalid("radius must be positive".into()));+ }+ let r = Region2 { outer: Loop2::circle(Vec2::ZERO, radius), holes: vec![] };+ let mut v = extrude(&plane, &[r], 0.0, finite(height, "height")?)?;+ v.pop().ok_or_else(|| KernelError::Failed("cylinder".into()))+}++/// Sphere: revolve a half disc.+pub fn sphere(center: Vec3, radius: f64) -> Result<Body> {+ let radius = finite(radius, "radius")?;+ if radius <= 1e-6 {+ return Err(KernelError::Invalid("radius must be positive".into()));+ }+ let plane = Plane { origin: center, ..Plane::XZ };+ let half = Loop2 {+ segs: vec![+ Seg2::Arc { center: Vec2::ZERO, radius, start: -std::f64::consts::FRAC_PI_2, sweep: std::f64::consts::PI },+ Seg2::Line { a: Vec2::new(0.0, radius), b: Vec2::new(0.0, -radius) },+ ],+ };+ let mut v = revolve(&plane, &[Region2 { outer: half, holes: vec![] }], Vec2::ZERO, Vec2::Y, std::f64::consts::TAU)?;+ v.pop().ok_or_else(|| KernelError::Failed("sphere".into()))+}++/// Torus about the Z axis through `center`.+pub fn torus(center: Vec3, major: f64, minor: f64) -> Result<Body> {+ let (major, minor) = (finite(major, "major radius")?, finite(minor, "minor radius")?);+ if !(minor > 1e-6 && major > minor) {+ return Err(KernelError::Invalid("torus needs major > minor > 0".into()));+ }+ let plane = Plane { origin: center, ..Plane::XZ };+ let r = Region2 { outer: Loop2::circle(Vec2::new(major, 0.0), minor), holes: vec![] };+ let mut v = revolve(&plane, &[r], Vec2::ZERO, Vec2::Y, std::f64::consts::TAU)?;+ v.pop().ok_or_else(|| KernelError::Failed("torus".into()))+}diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rsnew file mode 100644index 0000000000..05be595e00--- /dev/null+++ b/crates/kernel/src/lib.rs@@ -0,0 +1,55 @@+//! The B-rep kernel boundary.+//!+//! Everything SolveCraft does with solids goes through this crate: building bodies from planar+//! regions (extrude, revolve) and primitives, booleans, fillets and chamfers, tessellation,+//! measurement and STEP export. The implementation uses the `monstertruck` crates (Apache-2.0,+//! a maintained fork of `truck`; see `plan/adr/0001-geometry-kernel.md`), but no monstertruck+//! type appears in the public API, so the kernel can be replaced without touching the rest of+//! the workspace.+//!+//! Every call into the third-party kernel runs under [`guard`]: a panic inside it becomes a+//! [`KernelError::Internal`] instead of taking the application down.+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]+#![forbid(unsafe_code)]++mod body;+mod build;+mod measure;+mod ops;+mod step;+mod topo;++pub use body::{Body, EdgeInfo, FaceInfo};+pub use build::{box_solid, cylinder, extrude, revolve, sphere, torus};+pub use measure::{BodyMeasure, measure};+pub use ops::{BoolOp, boolean, chamfer, fillet, transform};+pub use step::step_export;+pub use topo::{TopoCounts, merged_topology};++#[derive(Debug, Clone, PartialEq, thiserror::Error)]+pub enum KernelError {+ #[error("invalid input: {0}")]+ Invalid(String),+ #[error("the operation failed: {0}")]+ Failed(String),+ /// The third-party kernel panicked; the model is unchanged.+ #[error("kernel internal error: {0}")]+ Internal(String),+}++pub type Result<T> = std::result::Result<T, KernelError>;++/// Run third-party kernel code, converting a panic into an error.+pub fn guard<T>(what: &str, f: impl FnOnce() -> Result<T>) -> Result<T> {+ match std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)) {+ Ok(r) => r,+ Err(p) => {+ let msg = p.downcast_ref::<&str>().map(|s| s.to_string()).or_else(|| p.downcast_ref::<String>().cloned()).unwrap_or_default();+ log::warn!("kernel panic in {what}: {msg}");+ Err(KernelError::Internal(format!("{what}: {msg}")))+ }+ }+}++#[cfg(test)]+mod tests;diff --git a/crates/kernel/src/measure.rs b/crates/kernel/src/measure.rsnew file mode 100644index 0000000000..d735979105--- /dev/null+++ b/crates/kernel/src/measure.rs@@ -0,0 +1,42 @@+use serde::Serialize;+use solvecraft_geom::{Aabb3, Vec3};++use crate::Result;+use crate::body::Body;+use crate::topo::{TopoCounts, merged_topology};++/// Measured properties of a body.+#[derive(Clone, Debug, Serialize)]+pub struct BodyMeasure {+ pub volume: f64,+ pub area: f64,+ pub centroid: Vec3,+ pub bbox: Aabb3,+ /// Raw kernel topology counts (closed curves and surfaces may be split in pieces).+ pub faces: usize,+ pub edges: usize,+ pub vertices: usize,+ pub shells: usize,+ /// Counts after merging split pieces of the same analytic surface/curve (comparable with+ /// systems that use periodic faces and edges).+ pub merged: TopoCounts,+}++/// Measure a body from a fine tessellation (chord tolerance 5e-5 of the body size). Curved+/// faces are slightly under-estimated (relative error typically below 2e-4).+pub fn measure(b: &Body) -> Result<BodyMeasure> {+ let size = b.size();+ let m2 = b.tessellate((size * 5e-5).max(1e-4))?;+ let a2 = m2.measure();+ Ok(BodyMeasure {+ volume: a2.volume,+ area: a2.area,+ centroid: a2.centroid,+ bbox: m2.bounds(),+ faces: b.face_count(),+ edges: b.edge_count(),+ vertices: b.vertex_count(),+ shells: b.shell_count(),+ merged: merged_topology(b, &m2)?,+ })+}diff --git a/crates/kernel/src/ops.rs b/crates/kernel/src/ops.rsnew file mode 100644index 0000000000..fa946bdf73--- /dev/null+++ b/crates/kernel/src/ops.rs@@ -0,0 +1,112 @@+//! Operations on bodies: booleans, fillets, chamfers, rigid transforms.++use monstertruck_modeling as mt;+use serde::{Deserialize, Serialize};+use solvecraft_geom::Vec3;++use crate::body::{Body, Solid, v3};+use crate::{KernelError, Result, guard};++#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]+#[serde(rename_all = "snake_case")]+pub enum BoolOp {+ Union,+ Cut,+ Intersect,+}++/// Boolean of two bodies. Retries with a few tolerances; the result may be empty (`Ok(None)`)+/// for a cut that removes everything or an intersection of disjoint bodies.+pub fn boolean(a: &Body, b: &Body, op: BoolOp) -> Result<Option<Body>> {+ let size = a.size().max(b.size());+ let mut last = String::new();+ for k in [1e-4, 1e-3, 5e-5, 5e-3] {+ let tol = (size * k).max(1e-6);+ let r = guard("boolean", || {+ let (sa, sb) = (a.deep_copy(), b.deep_copy());+ let res = match op {+ BoolOp::Union => monstertruck_solid::or(&sa, &sb, tol),+ BoolOp::Cut => monstertruck_solid::difference(&sa, &sb, tol),+ BoolOp::Intersect => monstertruck_solid::and(&sa, &sb, tol),+ };+ res.map_err(|e| KernelError::Failed(format!("{e:?}")))+ });+ match r {+ Ok(s) if s.is_empty() => return Ok(None),+ Ok(s) => {+ let body = Body::new(s)?;+ if body.tessellate(size * 1e-2).map(|m| m.measure().volume > 0.0).unwrap_or(false) {+ return Ok(Some(body));+ }+ last = "degenerate result".into();+ }+ Err(e) => last = e.to_string(),+ }+ }+ Err(KernelError::Failed(format!("boolean {op:?}: {last}")))+}++fn blend(body: &Body, edges: &[Vec3], radius: f64, profile: mt::FilletProfile, what: &str) -> Result<Body> {+ if !(radius.is_finite() && radius > 1e-6 && radius < 1e6) {+ return Err(KernelError::Invalid(format!("{what} size must be positive")));+ }+ if edges.is_empty() {+ return Err(KernelError::Invalid("no edges selected".into()));+ }+ let tol = (body.size() * 2e-3).max(1e-3);+ let mut cur = body.clone();+ // One edge at a time: re-find each edge on the current body by its reference point.+ for p in edges {+ let Some((idx, d)) = cur.nearest_edge(*p, tol)? else { return Err(KernelError::Invalid("body has no edges".into())) };+ if d > cur.size() * 0.05 + 1e-3 {+ return Err(KernelError::Invalid(format!("no edge near {:?}", [p.x, p.y, p.z])));+ }+ let mut solid = cur.deep_copy();+ let shape = profile.clone();+ let res = guard(what, || {+ let edge = Body::unique_edges(&solid).into_iter().nth(idx).ok_or_else(|| KernelError::Invalid("edge index".into()))?;+ let shell_i = solid+ .boundaries()+ .iter()+ .position(|sh| sh.edge_iter().any(|e| e.id() == edge.id()))+ .ok_or_else(|| KernelError::Failed("edge not in a shell".into()))?;+ let mut shells = solid.boundaries().clone();+ let shell = shells.get_mut(shell_i).ok_or_else(|| KernelError::Failed("shell".into()))?;+ let opts = mt::FilletOptions { radius: mt::RadiusSpec::Constant(radius), profile: shape, ..Default::default() };+ mt::fillet_edges(shell, &[edge], Some(&opts)).map_err(|e| KernelError::Failed(format!("{what}: {e:?}")))?;+ solid = Solid::try_new(shells).map_err(|e| KernelError::Failed(format!("{what} left an open shell: {e:?}")))?;+ Ok(())+ });+ res?;+ cur = Body::new(solid)?;+ }+ Ok(cur)+}++/// Constant-radius fillet of the edges nearest to the given points.+pub fn fillet(body: &Body, edges: &[Vec3], radius: f64) -> Result<Body> {+ blend(body, edges, radius, mt::FilletProfile::Round, "fillet")+}++/// Equal-distance chamfer of the edges nearest to the given points.+pub fn chamfer(body: &Body, edges: &[Vec3], distance: f64) -> Result<Body> {+ blend(body, edges, distance, mt::FilletProfile::Chamfer, "chamfer")+}++/// Rigid transform: rotate about `axis` through `origin` by `angle` radians, then translate.+pub fn transform(body: &Body, translate: Vec3, origin: Vec3, axis: Vec3, angle: f64) -> Result<Body> {+ if !(translate.is_finite() && origin.is_finite() && angle.is_finite()) {+ return Err(KernelError::Invalid("non-finite transform".into()));+ }+ guard("transform", || {+ let mut s = body.deep_copy();+ if angle.abs() > 1e-12 {+ let ax = axis.normalized().ok_or_else(|| KernelError::Invalid("rotation axis".into()))?;+ s = mt::builder::rotated(&s, crate::body::p3(origin), v3(ax), mt::Rad(angle));+ }+ if translate.len() > 0.0 {+ s = mt::builder::translated(&s, v3(translate));+ }+ Body::new(s)+ })+}diff --git a/crates/kernel/src/step.rs b/crates/kernel/src/step.rsnew file mode 100644index 0000000000..c35cb337bb--- /dev/null+++ b/crates/kernel/src/step.rs@@ -0,0 +1,18 @@+use monstertruck_io::step::save;++use crate::body::Body;+use crate::{KernelError, Result, guard};++/// STEP (ISO 10303-21, AP203-style geometry) text for the given bodies.+pub fn step_export(bodies: &[&Body], system: &str) -> Result<String> {+ if bodies.is_empty() {+ return Err(KernelError::Invalid("nothing to export".into()));+ }+ guard("step export", || {+ let cs: Vec<_> = bodies.iter().map(|b| b.solid.compress()).collect();+ let models = save::StepModels::from_iter(cs.iter());+ let header = save::StepHeaderDescriptor { organization_system: system.to_owned(), ..Default::default() };+ let out = save::CompleteStepDisplay::new(models, header).to_string();+ Ok(out)+ })+}diff --git a/crates/kernel/src/tests.rs b/crates/kernel/src/tests.rsnew file mode 100644index 0000000000..314299373b--- /dev/null+++ b/crates/kernel/src/tests.rs@@ -0,0 +1,137 @@+use std::f64::consts::PI;++use solvecraft_geom::{Loop2, Plane, Region2, Vec2, Vec3};++use crate::*;++fn rel(a: f64, b: f64) -> f64 {+ (a - b).abs() / b.abs().max(1e-12)+}++fn rect(w: f64, h: f64) -> Region2 {+ Region2 { outer: Loop2::polygon(&[Vec2::new(0.0, 0.0), Vec2::new(w, 0.0), Vec2::new(w, h), Vec2::new(0.0, h)]), holes: vec![] }+}++#[test]+fn box_extrude_measures() {+ let b = extrude(&Plane::XY, &[rect(40.0, 30.0)], 0.0, 20.0).unwrap().pop().unwrap();+ let m = measure(&b).unwrap();+ assert!(rel(m.volume, 24000.0) < 1e-9, "{}", m.volume);+ assert!(rel(m.area, 5200.0) < 1e-9);+ assert_eq!((m.faces, m.edges, m.vertices), (6, 12, 8));+ assert_eq!((m.merged.faces, m.merged.edges, m.merged.vertices), (6, 12, 8));+ assert!(m.centroid.dist(Vec3::new(20.0, 15.0, 10.0)) < 1e-6);+}++#[test]+fn cylinder_measures_match_analytic() {+ let b = extrude(&Plane::XY, &[Region2 { outer: Loop2::circle(Vec2::ZERO, 15.0), holes: vec![] }], 0.0, 50.0).unwrap().pop().unwrap();+ let m = measure(&b).unwrap();+ let v = PI * 225.0 * 50.0;+ let a = 2.0 * PI * 225.0 + 2.0 * PI * 15.0 * 50.0;+ assert!(rel(m.volume, v) < 5e-4, "{} vs {v}", m.volume);+ assert!(rel(m.area, a) < 5e-4, "{} vs {a}", m.area);+ assert_eq!((m.merged.faces, m.merged.edges, m.merged.vertices), (3, 2, 2), "{:?}", m.merged);+ assert_eq!(m.merged.face_types.get("cylinder"), Some(&1));+}++#[test]+fn extrude_on_other_planes_and_offsets() {+ let b = extrude(&Plane::XZ, &[rect(10.0, 5.0)], -2.0, 3.0).unwrap().pop().unwrap();+ let m = measure(&b).unwrap();+ assert!(rel(m.volume, 250.0) < 1e-9);+ // XZ normal is -Y: the body spans y in [-3, 2].+ assert!((m.bbox.min.y + 3.0).abs() < 1e-6 && (m.bbox.max.y - 2.0).abs() < 1e-6, "{:?}", m.bbox);+}++#[test]+fn region_with_hole() {+ let r = Region2 { outer: rect(40.0, 30.0).outer, holes: vec![Loop2::circle(Vec2::new(20.0, 15.0), 5.0).reversed()] };+ let b = extrude(&Plane::XY, &[r], 0.0, 10.0).unwrap().pop().unwrap();+ let m = measure(&b).unwrap();+ assert!(rel(m.volume, (1200.0 - PI * 25.0) * 10.0) < 5e-4, "{}", m.volume);+}++#[test]+fn box_fillet_cut_volume() {+ let b = box_solid(Vec3::ZERO, Vec3::new(40.0, 30.0, 20.0)).unwrap();+ let f = fillet(&b, &[Vec3::new(0.0, 0.0, 10.0)], 3.0).unwrap();+ let mf = measure(&f).unwrap();+ let expect_f = 24000.0 - (9.0 - PI * 9.0 / 4.0) * 20.0;+ assert!(rel(mf.volume, expect_f) < 1e-4, "{} vs {expect_f}", mf.volume);+ assert_eq!(mf.merged.faces, 7);+ let hole = cylinder(Vec3::new(20.0, 15.0, -5.0), Vec3::Z, 5.0, 30.0).unwrap();+ let cut = boolean(&f, &hole, BoolOp::Cut).unwrap().unwrap();+ let mc = measure(&cut).unwrap();+ let expect = expect_f - PI * 25.0 * 20.0;+ assert!(rel(mc.volume, expect) < 1e-3, "{} vs {expect}", mc.volume);+}++#[test]+fn union_and_intersect() {+ let a = box_solid(Vec3::ZERO, Vec3::new(10.0, 10.0, 10.0)).unwrap();+ let b = box_solid(Vec3::new(5.0, 5.0, 5.0), Vec3::new(15.0, 15.0, 15.0)).unwrap();+ let u = boolean(&a, &b, BoolOp::Union).unwrap().unwrap();+ assert!(rel(measure(&u).unwrap().volume, 2000.0 - 125.0) < 1e-6);+ let i = boolean(&a, &b, BoolOp::Intersect).unwrap().unwrap();+ assert!(rel(measure(&i).unwrap().volume, 125.0) < 1e-6);+}++#[test]+fn revolve_washer_and_sphere() {+ let r =+ Region2 { outer: Loop2::polygon(&[Vec2::new(10.0, 0.0), Vec2::new(15.0, 0.0), Vec2::new(15.0, 5.0), Vec2::new(10.0, 5.0)]), holes: vec![] };+ let b = revolve(&Plane::XZ, std::slice::from_ref(&r), Vec2::ZERO, Vec2::Y, 2.0 * PI).unwrap().pop().unwrap();+ let m = measure(&b).unwrap();+ let v = PI * (225.0 - 100.0) * 5.0;+ assert!(rel(m.volume, v) < 5e-4, "{} vs {v}", m.volume);+ let half = revolve(&Plane::XZ, &[r], Vec2::ZERO, Vec2::Y, PI).unwrap().pop().unwrap();+ assert!(rel(measure(&half).unwrap().volume, v / 2.0) < 5e-4);+ let s = sphere(Vec3::new(1.0, 2.0, 3.0), 10.0).unwrap();+ let ms = measure(&s).unwrap();+ assert!(rel(ms.volume, 4.0 / 3.0 * PI * 1000.0) < 1e-3, "{}", ms.volume);+}++#[test]+fn chamfer_and_step() {+ let b = box_solid(Vec3::ZERO, Vec3::new(20.0, 20.0, 20.0)).unwrap();+ let c = chamfer(&b, &[Vec3::new(20.0, 10.0, 20.0)], 2.0).unwrap();+ assert!(rel(measure(&c).unwrap().volume, 8000.0 - 2.0 * 20.0) < 1e-4);+ let s = step_export(&[&c], "SolveCraft").unwrap();+ assert!(s.starts_with("ISO-10303-21;"));+ assert!(s.contains("MANIFOLD_SOLID_BREP") || s.contains("CLOSED_SHELL"));+}++#[test]+fn hostile_inputs_are_errors() {+ assert!(extrude(&Plane::XY, &[rect(1.0, 1.0)], 0.0, 0.0).is_err());+ assert!(extrude(&Plane::XY, &[rect(1.0, 1.0)], 0.0, f64::NAN).is_err());+ assert!(extrude(&Plane::XY, &[], 0.0, 1.0).is_err());+ assert!(extrude(&Plane::XY, &[rect(0.0, 1.0)], 0.0, 1.0).is_err());+ assert!(box_solid(Vec3::ZERO, Vec3::new(1.0, 0.0, 1.0)).is_err());+ assert!(cylinder(Vec3::ZERO, Vec3::ZERO, 1.0, 1.0).is_err());+ let b = box_solid(Vec3::ZERO, Vec3::new(10.0, 10.0, 10.0)).unwrap();+ assert!(fillet(&b, &[Vec3::new(0.0, 0.0, 5.0)], -1.0).is_err());+ assert!(fillet(&b, &[Vec3::new(500.0, 0.0, 5.0)], 1.0).is_err());+ assert!(fillet(&b, &[Vec3::new(0.0, 0.0, 5.0)], 100.0).is_err());+ let r = Region2 { outer: Loop2::polygon(&[Vec2::new(-1.0, 0.0), Vec2::new(1.0, 0.0), Vec2::new(1.0, 1.0)]), holes: vec![] };+ assert!(revolve(&Plane::XZ, &[r], Vec2::ZERO, Vec2::Y, 1.0).is_err(), "crosses axis");+ assert!(transform(&b, Vec3::new(f64::NAN, 0.0, 0.0), Vec3::ZERO, Vec3::Z, 0.0).is_err());+}++#[test]+#[ignore]+fn debug_convergence() {+ let b = extrude(&Plane::XY, &[Region2 { outer: Loop2::circle(Vec2::ZERO, 15.0), holes: vec![] }], 0.0, 50.0).unwrap().pop().unwrap();+ for t in [0.1, 0.05, 0.02, 0.01, 0.005, 0.002] {+ let m = b.tessellate(t).unwrap();+ let mm = m.measure();+ println!("tol {t}: tris {} vol {} err {:.3e}", m.triangles.len(), mm.volume, mm.volume / (PI * 225.0 * 50.0) - 1.0);+ }+ let m = b.tessellate(0.05).unwrap();+ for f in 0..4u32 {+ let ns: Vec<Vec3> =+ m.triangles.iter().zip(&m.tri_face).filter(|(_, ff)| **ff == f).flat_map(|(t, _)| t.iter().map(|k| m.normals[*k as usize])).collect();+ println!("face {f}: {} normals, first {:?}, max |n.z| {}", ns.len(), ns.first(), ns.iter().map(|n| n.z.abs()).fold(0.0, f64::max));+ }+}diff --git a/crates/kernel/src/topo.rs b/crates/kernel/src/topo.rsnew file mode 100644index 0000000000..b0b982c25c--- /dev/null+++ b/crates/kernel/src/topo.rs@@ -0,0 +1,263 @@+//! Topology counts comparable with kernels that use periodic faces and closed edges.+//!+//! Our kernel splits a full cylinder into two half faces and a circle into two arcs. Faces+//! are classified from their tessellation (plane, cylinder, sphere, other); adjacent faces on+//! the same analytic surface are merged, edges between merged faces disappear, and chains of+//! edges through vertices that only join two pieces of the same edge are counted once.++use std::collections::{BTreeMap, HashMap};++use serde::Serialize;+use solvecraft_geom::{Mesh, Vec3};++use crate::Result;+use crate::body::{Body, from_p3};++#[derive(Clone, Debug, Default, Serialize, PartialEq)]+pub struct TopoCounts {+ pub faces: usize,+ pub edges: usize,+ pub vertices: usize,+ pub face_types: BTreeMap<String, usize>,+}++#[derive(Clone, Copy, Debug, PartialEq)]+enum Surf {+ Plane { n: Vec3, d: f64 },+ Cylinder { axis: Vec3, p: Vec3, r: f64 },+ Sphere { c: Vec3, r: f64 },+ Other(usize),+}++impl Surf {+ fn name(&self) -> &'static str {+ match self {+ Surf::Plane { .. } => "plane",+ Surf::Cylinder { .. } => "cylinder",+ Surf::Sphere { .. } => "sphere",+ Surf::Other(_) => "other",+ }+ }+ fn same(&self, o: &Surf, tol: f64) -> bool {+ match (*self, *o) {+ (Surf::Plane { n, d }, Surf::Plane { n: n2, d: d2 }) => n.dot(n2) > 1.0 - 1e-6 && (d - d2).abs() < tol,+ (Surf::Cylinder { axis, p, r }, Surf::Cylinder { axis: a2, p: p2, r: r2 }) => {+ let off = p2 - p;+ axis.dot(a2).abs() > 1.0 - 1e-6 && (r - r2).abs() < tol && (off - axis * off.dot(axis)).len() < tol+ }+ (Surf::Sphere { c, r }, Surf::Sphere { c: c2, r: r2 }) => c.dist(c2) < tol && (r - r2).abs() < tol,+ _ => false,+ }+ }+}++/// Least-squares circle through 2D points (Kåsa fit): centre and radius.+fn fit_circle(pts: &[(f64, f64)]) -> Option<(f64, f64, f64)> {+ let n = pts.len() as f64;+ if pts.len() < 3 {+ return None;+ }+ let (mx, my) = pts.iter().fold((0.0, 0.0), |a, p| (a.0 + p.0 / n, a.1 + p.1 / n));+ let (mut suu, mut suv, mut svv, mut suuu, mut svvv, mut suvv, mut svuu) = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);+ for (x, y) in pts {+ let (u, v) = (x - mx, y - my);+ suu += u * u;+ suv += u * v;+ svv += v * v;+ suuu += u * u * u;+ svvv += v * v * v;+ suvv += u * v * v;+ svuu += v * u * u;+ }+ let det = suu * svv - suv * suv;+ if det.abs() < 1e-18 {+ return None;+ }+ let b1 = 0.5 * (suuu + suvv);+ let b2 = 0.5 * (svvv + svuu);+ let uc = (b1 * svv - b2 * suv) / det;+ let vc = (suu * b2 - suv * b1) / det;+ let r = (uc * uc + vc * vc + (suu + svv) / n).sqrt();+ Some((uc + mx, vc + my, r))+}++fn classify(pts: &[Vec3], nrm: &[Vec3], tol: f64, id: usize) -> Surf {+ let Some(&n0) = nrm.first() else { return Surf::Other(id) };+ let Some(&p0) = pts.first() else { return Surf::Other(id) };+ if nrm.iter().all(|n| n.dot(n0) > 1.0 - 1e-5) {+ let n = n0.normalized().unwrap_or(Vec3::Z);+ if pts.iter().all(|p| (p.dot(n) - p0.dot(n)).abs() < tol) {+ return Surf::Plane { n, d: p0.dot(n) };+ }+ }+ // Cylinder: all normals perpendicular to one axis.+ let far = nrm.iter().copied().min_by(|a, b| a.dot(n0).abs().total_cmp(&b.dot(n0).abs())).unwrap_or(n0);+ if let Some(axis) = n0.cross(far).normalized()+ && nrm.iter().all(|n| n.dot(axis).abs() < 2e-3)+ {+ let u = axis.any_perp();+ let v = axis.cross(u);+ let pl: Vec<(f64, f64)> = pts.iter().map(|p| (p.dot(u), p.dot(v))).collect();+ if let Some((cu, cv, r)) = fit_circle(&pl)+ && pl.iter().all(|(x, y)| ((x - cu).hypot(y - cv) - r).abs() < tol.max(r * 2e-3))+ {+ let axis = if axis.x + axis.y * 1e-3 + axis.z * 1e-6 < 0.0 { -axis } else { axis };+ return Surf::Cylinder { axis, p: u * cu + v * cv, r };+ }+ }+ // Sphere: points equidistant from the point where normals meet.+ let c_est = {+ let mut acc = Vec3::ZERO;+ let mut k = 0.0;+ for (p, n) in pts.iter().zip(nrm) {+ // Assume radius from the first pair.+ let r0 = (p0 - *p).len() / ((n0 - *n).len().max(1e-12));+ if r0.is_finite() && r0 > 0.0 && (n0 - *n).len() > 0.1 {+ acc += *p - *n * r0;+ k += 1.0;+ }+ }+ (k > 0.0).then(|| acc / k)+ };+ if let Some(c) = c_est {+ let r = pts.iter().map(|p| p.dist(c)).sum::<f64>() / pts.len().max(1) as f64;+ if pts.iter().all(|p| (p.dist(c) - r).abs() < tol.max(r * 2e-3)) {+ return Surf::Sphere { c, r };+ }+ }+ Surf::Other(id)+}++fn find(p: &mut [usize], mut i: usize) -> usize {+ while let Some(&q) = p.get(i) {+ if q == i {+ break;+ }+ i = q;+ }+ i+}++/// Merged face/edge/vertex counts (see module docs). `mesh` must be `b.tessellate(..)`.+pub fn merged_topology(b: &Body, mesh: &Mesh) -> Result<TopoCounts> {+ let solid = &*b.solid;+ let nf = solid.face_iter().count();+ let tol = (b.size() * 1e-4).max(1e-6);+ let mut pts: Vec<Vec<Vec3>> = vec![Vec::new(); nf];+ let mut nrm: Vec<Vec<Vec3>> = vec![Vec::new(); nf];+ for (t, f) in mesh.triangles.iter().zip(&mesh.tri_face) {+ for &k in t {+ if let (Some(p), Some(n), Some(pv), Some(nv)) =+ (mesh.positions.get(k as usize), mesh.normals.get(k as usize), pts.get_mut(*f as usize), nrm.get_mut(*f as usize))+ {+ pv.push(*p);+ nv.push(*n);+ }+ }+ }+ let surfs: Vec<Surf> = (0..nf)+ .map(|i| classify(pts.get(i).map(Vec::as_slice).unwrap_or(&[]), nrm.get(i).map(Vec::as_slice).unwrap_or(&[]), tol * 10.0, i))+ .collect();++ // Edge → faces, edge → vertices.+ let mut edge_faces: HashMap<usize, Vec<usize>> = HashMap::new();+ let mut edge_verts: HashMap<usize, (usize, usize)> = HashMap::new();+ let mut eid: HashMap<String, usize> = HashMap::new();+ let mut vid: HashMap<String, usize> = HashMap::new();+ let mut vpos: Vec<Vec3> = Vec::new();+ for (fi, f) in solid.face_iter().enumerate() {+ for e in f.edge_iter() {+ let key = format!("{:?}", e.id());+ let n = eid.len();+ let ei = *eid.entry(key).or_insert(n);+ let faces = edge_faces.entry(ei).or_default();+ if !faces.contains(&fi) {+ faces.push(fi);+ }+ let mut vix = |v: &monstertruck_modeling::Vertex| {+ let k = format!("{:?}", v.id());+ let n = vid.len();+ let i = *vid.entry(k).or_insert(n);+ if i == vpos.len() {+ vpos.push(from_p3(v.point()));+ }+ i+ };+ let (a, bb) = (vix(e.front()), vix(e.back()));+ edge_verts.insert(ei, (a, bb));+ }+ }+ // Merge faces.+ let mut fp: Vec<usize> = (0..nf).collect();+ for faces in edge_faces.values() {+ if let [a, b] = faces[..]+ && let (Some(sa), Some(sb)) = (surfs.get(a), surfs.get(b))+ && sa.same(sb, tol * 10.0)+ {+ let (ra, rb) = (find(&mut fp, a), find(&mut fp, b));+ if let Some(s) = fp.get_mut(ra) {+ *s = rb;+ }+ }+ }+ let mut groups: BTreeMap<usize, usize> = BTreeMap::new();+ let mut face_types: BTreeMap<String, usize> = BTreeMap::new();+ for f in 0..nf {+ let r = find(&mut fp, f);+ if groups.insert(r, f).is_none()+ && let Some(s) = surfs.get(f)+ {+ *face_types.entry(s.name().into()).or_insert(0) += 1;+ }+ }+ // Remaining edges, keyed by merged face pair.+ let mut remaining: Vec<(usize, (usize, usize), (usize, usize))> = Vec::new(); // (edge, verts, face pair)+ let mut eids: Vec<&usize> = edge_faces.keys().collect();+ eids.sort();+ for e in eids {+ let faces = edge_faces.get(e).cloned().unwrap_or_default();+ let gs: Vec<usize> = faces.iter().map(|f| find(&mut fp, *f)).collect();+ let pair = match gs[..] {+ [a, b] if a == b => continue,+ [a, b] => (a.min(b), a.max(b)),+ [a] => (a, a),+ _ => (usize::MAX, usize::MAX),+ };+ if let Some(v) = edge_verts.get(e) {+ remaining.push((*e, *v, pair));+ }+ }+ // Vertex degree among remaining edges.+ let mut deg: HashMap<usize, Vec<usize>> = HashMap::new();+ for (i, (_, (a, b), _)) in remaining.iter().enumerate() {+ deg.entry(*a).or_default().push(i);+ if b != a {+ deg.entry(*b).or_default().push(i);+ }+ }+ let mut ep: Vec<usize> = (0..remaining.len()).collect();+ let mut merge_vertex: Vec<usize> = Vec::new();+ for (v, es) in ° {+ if let [i, j] = es[..]+ && let (Some(a), Some(b)) = (remaining.get(i), remaining.get(j))+ && a.2 == b.2+ {+ let (ri, rj) = (find(&mut ep, i), find(&mut ep, j));+ if let Some(s) = ep.get_mut(ri) {+ *s = rj;+ }+ merge_vertex.push(*v);+ }+ }+ let mut edge_groups: BTreeMap<usize, bool> = BTreeMap::new(); // root → has a real end vertex+ for (i, (_, (a, b), _)) in remaining.iter().enumerate() {+ let r = find(&mut ep, i);+ let real = !merge_vertex.contains(a) || !merge_vertex.contains(b);+ let e = edge_groups.entry(r).or_insert(false);+ *e |= real;+ }+ let real_vertices = deg.keys().filter(|v| !merge_vertex.contains(v)).count();+ let closed_loops = edge_groups.values().filter(|r| !**r).count();+ let _ = vpos;+ Ok(TopoCounts { faces: groups.len(), edges: edge_groups.len(), vertices: real_vertices + closed_loops, face_types })+}diff --git a/crates/render/Cargo.toml b/crates/render/Cargo.tomlnew file mode 100644index 0000000000..41f84311e4--- /dev/null+++ b/crates/render/Cargo.toml@@ -0,0 +1,8 @@+[package]+name = "solvecraft-render"+version.workspace = true+edition.workspace = true+license.workspace = true++[lints]+workspace = truediff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rsnew file mode 100644index 0000000000..8b13789179--- /dev/null+++ b/crates/render/src/lib.rs@@ -0,0 +1 @@+diff --git a/crates/sketch/Cargo.toml b/crates/sketch/Cargo.tomlnew file mode 100644index 0000000000..782c883bb4--- /dev/null+++ b/crates/sketch/Cargo.toml@@ -0,0 +1,17 @@+[package]+name = "solvecraft-sketch"+description = "SolveCraft sketches: points, curves, geometric constraints and dimensions, the constraint solver, and profile detection"+version.workspace = true+edition.workspace = true+license.workspace = true++[lints]+workspace = true++[dependencies]+solvecraft-geom = { workspace = true }+serde = { workspace = true }+thiserror = { workspace = true }++[dev-dependencies]+serde_json = { workspace = true }diff --git a/crates/sketch/src/lib.rs b/crates/sketch/src/lib.rsnew file mode 100644index 0000000000..70ac6c5bbe--- /dev/null+++ b/crates/sketch/src/lib.rs@@ -0,0 +1,21 @@+//! Sketches: points and curves on a plane, geometric constraints and driving dimensions, a+//! Levenberg–Marquardt constraint solver with degree-of-freedom analysis, and closed-profile+//! (region) detection for features.+//!+//! The solver is our own clean-room implementation (residual functions per constraint, local+//! finite-difference Jacobians, damped Gauss–Newton per connected component, rank analysis by+//! Gaussian elimination). See `plan/architecture.md` §sketch.+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]+#![forbid(unsafe_code)]++mod linalg;+mod model;+mod profiles;+mod solver;++pub use model::{Constraint, ConstraintKind, Curve, CurveKind, SPoint, Sketch, SketchError};+pub use profiles::{Profile, find_profiles};+pub use solver::{SolveReport, SolveStatus, solve};++#[cfg(test)]+mod tests;diff --git a/crates/sketch/src/linalg.rs b/crates/sketch/src/linalg.rsnew file mode 100644index 0000000000..3954c9b8fc--- /dev/null+++ b/crates/sketch/src/linalg.rs@@ -0,0 +1,182 @@+//! Small dense linear algebra for the solver: row-major matrices, Gaussian elimination with+//! partial pivoting, and reduced row echelon form for rank and null-space analysis.++/// Row-major dense matrix.+#[derive(Clone, Debug)]+pub struct Mat {+ pub rows: usize,+ pub cols: usize,+ pub data: Vec<f64>,+}++impl Mat {+ pub fn zeros(rows: usize, cols: usize) -> Mat {+ Mat { rows, cols, data: vec![0.0; rows.saturating_mul(cols)] }+ }+ pub fn get(&self, r: usize, c: usize) -> f64 {+ self.data.get(r * self.cols + c).copied().unwrap_or(0.0)+ }+ pub fn set(&mut self, r: usize, c: usize, v: f64) {+ if let Some(x) = self.data.get_mut(r * self.cols + c) {+ *x = v;+ }+ }+ pub fn add(&mut self, r: usize, c: usize, v: f64) {+ if let Some(x) = self.data.get_mut(r * self.cols + c) {+ *x += v;+ }+ }+ fn swap_rows(&mut self, a: usize, b: usize) {+ if a == b {+ return;+ }+ for c in 0..self.cols {+ self.data.swap(a * self.cols + c, b * self.cols + c);+ }+ }+}++/// Solve `A x = b` (A square). Returns `None` when singular.+pub fn solve(mut a: Mat, mut b: Vec<f64>) -> Option<Vec<f64>> {+ let n = a.rows;+ if a.cols != n || b.len() != n {+ return None;+ }+ for k in 0..n {+ let mut piv = k;+ let mut best = a.get(k, k).abs();+ for r in k + 1..n {+ let v = a.get(r, k).abs();+ if v > best {+ best = v;+ piv = r;+ }+ }+ if !(best > 1e-300) || !best.is_finite() {+ return None;+ }+ a.swap_rows(k, piv);+ b.swap(k, piv);+ let d = a.get(k, k);+ for r in k + 1..n {+ let f = a.get(r, k) / d;+ if f == 0.0 {+ continue;+ }+ for c in k..n {+ let v = a.get(k, c);+ a.add(r, c, -f * v);+ }+ let bk = *b.get(k)?;+ *b.get_mut(r)? -= f * bk;+ }+ }+ let mut x = vec![0.0; n];+ for k in (0..n).rev() {+ let mut s = *b.get(k)?;+ for c in k + 1..n {+ s -= a.get(k, c) * x.get(c)?;+ }+ *x.get_mut(k)? = s / a.get(k, k);+ }+ x.iter().all(|v| v.is_finite()).then_some(x)+}++/// Reduce to row echelon form in place; returns the pivot column of each pivot row.+pub fn rref(a: &mut Mat, tol: f64) -> Vec<usize> {+ let mut pivots = Vec::new();+ let mut row = 0;+ for col in 0..a.cols {+ if row >= a.rows {+ break;+ }+ let mut piv = row;+ let mut best = a.get(row, col).abs();+ for r in row + 1..a.rows {+ let v = a.get(r, col).abs();+ if v > best {+ best = v;+ piv = r;+ }+ }+ if !(best > tol) {+ continue;+ }+ a.swap_rows(row, piv);+ let d = a.get(row, col);+ for c in 0..a.cols {+ let v = a.get(row, c) / d;+ a.set(row, c, v);+ }+ for r in 0..a.rows {+ if r == row {+ continue;+ }+ let f = a.get(r, col);+ if f == 0.0 {+ continue;+ }+ for c in 0..a.cols {+ let v = a.get(row, c);+ a.add(r, c, -f * v);+ }+ }+ pivots.push(col);+ row += 1;+ }+ pivots+}++/// For each column of `j`: is that variable fixed by the constraints (zero in every null-space+/// vector)? Also returns the rank.+pub fn determined_vars(j: &Mat, tol: f64) -> (Vec<bool>, usize) {+ let mut a = j.clone();+ let pivots = rref(&mut a, tol);+ let rank = pivots.len();+ let free: Vec<usize> = (0..a.cols).filter(|c| !pivots.contains(c)).collect();+ let mut det = vec![true; a.cols];+ for f in &free {+ if let Some(d) = det.get_mut(*f) {+ *d = false;+ }+ }+ // Null vector for free column f: x_f = 1, x_pivot(r) = -a[r][f].+ for (r, pc) in pivots.iter().enumerate() {+ if free.iter().any(|f| a.get(r, *f).abs() > tol)+ && let Some(d) = det.get_mut(*pc)+ {+ *d = false;+ }+ }+ (det, rank)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn solves_and_detects_singular() {+ let mut a = Mat::zeros(2, 2);+ a.set(0, 0, 2.0);+ a.set(0, 1, 1.0);+ a.set(1, 0, 1.0);+ a.set(1, 1, 3.0);+ let x = solve(a, vec![3.0, 5.0]).unwrap();+ assert!((x[0] - 0.8).abs() < 1e-12 && (x[1] - 1.4).abs() < 1e-12);+ let s = Mat::zeros(2, 2);+ assert!(solve(s, vec![1.0, 1.0]).is_none());+ }++ #[test]+ fn rank_and_determined() {+ // x0 + x1 = .., x2 = .. ; x0 and x1 not individually determined.+ let mut j = Mat::zeros(2, 3);+ j.set(0, 0, 1.0);+ j.set(0, 1, 1.0);+ j.set(1, 2, 1.0);+ let (det, rank) = determined_vars(&j, 1e-9);+ assert_eq!(rank, 2);+ assert_eq!(det, vec![false, false, true]);+ }+}diff --git a/crates/sketch/src/model.rs b/crates/sketch/src/model.rsnew file mode 100644index 0000000000..4774243bab--- /dev/null+++ b/crates/sketch/src/model.rs@@ -0,0 +1,674 @@+use serde::{Deserialize, Serialize};+use solvecraft_geom::{Seg2, Vec2};++/// Hard caps that keep hostile input from exhausting memory or time.+pub const MAX_POINTS: usize = 20_000;+pub const MAX_CONSTRAINTS: usize = 40_000;++#[derive(Debug, Clone, PartialEq, thiserror::Error)]+pub enum SketchError {+ #[error("unknown sketch entity `{0}`")]+ Unknown(String),+ #[error("`{0}` is the wrong kind of entity for this: {1}")]+ WrongKind(String, String),+ #[error("duplicate id `{0}`")]+ Duplicate(String),+ #[error("invalid value: {0}")]+ Invalid(String),+ #[error("sketch is too large")]+ TooLarge,+}++type Result<T> = std::result::Result<T, SketchError>;++/// A sketch point. `fixed` points are constants for the solver.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+pub struct SPoint {+ pub id: String,+ pub pos: Vec2,+ #[serde(default)]+ pub fixed: bool,+}++#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[serde(tag = "type", rename_all = "snake_case")]+pub enum CurveKind {+ /// Segment between two points (indices into `Sketch::points`).+ Line { a: usize, b: usize },+ /// Full circle: centre point and radius.+ Circle { c: usize, r: f64 },+ /// Counter-clockwise arc around `c` from `a` to `b` (radius = |a − c|; the solver keeps+ /// |b − c| equal to it).+ Arc { c: usize, a: usize, b: usize },+}++#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+pub struct Curve {+ pub id: String,+ #[serde(flatten)]+ pub kind: CurveKind,+ #[serde(default)]+ pub construction: bool,+}++/// Geometric constraints and dimensions. Indices refer to `Sketch::points` (`p`, `q`) or+/// `Sketch::curves` (`l`, `c`, `a`, `b`). Dimension values are millimetres or radians.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[serde(tag = "type", rename_all = "snake_case")]+pub enum ConstraintKind {+ Coincident {+ p: usize,+ q: usize,+ },+ PointOnCurve {+ p: usize,+ c: usize,+ },+ Horizontal {+ l: usize,+ },+ Vertical {+ l: usize,+ },+ HorizontalPoints {+ p: usize,+ q: usize,+ },+ VerticalPoints {+ p: usize,+ q: usize,+ },+ Parallel {+ a: usize,+ b: usize,+ },+ Perpendicular {+ a: usize,+ b: usize,+ },+ Collinear {+ a: usize,+ b: usize,+ },+ Tangent {+ a: usize,+ b: usize,+ },+ Equal {+ a: usize,+ b: usize,+ },+ Concentric {+ a: usize,+ b: usize,+ },+ Midpoint {+ p: usize,+ l: usize,+ },+ Symmetric {+ p: usize,+ q: usize,+ l: usize,+ },+ Fix {+ p: usize,+ },+ // Dimensions (driving).+ Distance {+ p: usize,+ q: usize,+ value: f64,+ },+ DistanceX {+ p: usize,+ q: usize,+ value: f64,+ },+ DistanceY {+ p: usize,+ q: usize,+ value: f64,+ },+ PointLineDistance {+ p: usize,+ l: usize,+ value: f64,+ },+ Length {+ l: usize,+ value: f64,+ },+ Radius {+ c: usize,+ value: f64,+ },+ Diameter {+ c: usize,+ value: f64,+ },+ /// Angle from line `a` to line `b`, radians, counter-clockwise.+ Angle {+ a: usize,+ b: usize,+ value: f64,+ },+}++impl ConstraintKind {+ pub fn is_dimension(&self) -> bool {+ self.value().is_some()+ }+ pub fn value(&self) -> Option<f64> {+ use ConstraintKind::*;+ match *self {+ Distance { value, .. }+ | DistanceX { value, .. }+ | DistanceY { value, .. }+ | PointLineDistance { value, .. }+ | Length { value, .. }+ | Radius { value, .. }+ | Diameter { value, .. }+ | Angle { value, .. } => Some(value),+ _ => None,+ }+ }+ pub fn set_value(&mut self, v: f64) {+ use ConstraintKind::*;+ match self {+ Distance { value, .. }+ | DistanceX { value, .. }+ | DistanceY { value, .. }+ | PointLineDistance { value, .. }+ | Length { value, .. }+ | Radius { value, .. }+ | Diameter { value, .. }+ | Angle { value, .. } => *value = v,+ _ => {}+ }+ }+ pub fn is_angle(&self) -> bool {+ matches!(self, ConstraintKind::Angle { .. })+ }+ /// Short type name (Fusion-like) for listings.+ pub fn name(&self) -> &'static str {+ use ConstraintKind::*;+ match self {+ Coincident { .. } | PointOnCurve { .. } => "Coincident",+ Horizontal { .. } | HorizontalPoints { .. } => "Horizontal",+ Vertical { .. } | VerticalPoints { .. } => "Vertical",+ Parallel { .. } => "Parallel",+ Perpendicular { .. } => "Perpendicular",+ Collinear { .. } => "Collinear",+ Tangent { .. } => "Tangent",+ Equal { .. } => "Equal",+ Concentric { .. } => "Concentric",+ Midpoint { .. } => "MidPoint",+ Symmetric { .. } => "Symmetry",+ Fix { .. } => "Fix",+ Distance { .. } | DistanceX { .. } | DistanceY { .. } | PointLineDistance { .. } | Length { .. } => "LinearDimension",+ Radius { .. } => "RadialDimension",+ Diameter { .. } => "DiameterDimension",+ Angle { .. } => "AngularDimension",+ }+ }+ fn indices(&self) -> (Vec<usize>, Vec<usize>) {+ use ConstraintKind::*;+ match *self {+ Coincident { p, q } | HorizontalPoints { p, q } | VerticalPoints { p, q } => (vec![p, q], vec![]),+ Distance { p, q, .. } | DistanceX { p, q, .. } | DistanceY { p, q, .. } => (vec![p, q], vec![]),+ PointOnCurve { p, c } => (vec![p], vec![c]),+ Horizontal { l } | Vertical { l } | Length { l, .. } => (vec![], vec![l]),+ Radius { c, .. } | Diameter { c, .. } => (vec![], vec![c]),+ Parallel { a, b } | Perpendicular { a, b } | Collinear { a, b } | Tangent { a, b } | Equal { a, b } | Concentric { a, b } => {+ (vec![], vec![a, b])+ }+ Angle { a, b, .. } => (vec![], vec![a, b]),+ Midpoint { p, l } | PointLineDistance { p, l, .. } => (vec![p], vec![l]),+ Symmetric { p, q, l } => (vec![p, q], vec![l]),+ Fix { p } => (vec![p], vec![]),+ }+ }+ fn remap(&mut self, pmap: &dyn Fn(usize) -> Option<usize>, cmap: &dyn Fn(usize) -> Option<usize>) -> bool {+ use ConstraintKind::*;+ let mut ok = true;+ let mut fp = |i: &mut usize| match pmap(*i) {+ Some(n) => *i = n,+ None => ok = false,+ };+ let mut ok2 = true;+ let mut fc = |i: &mut usize| match cmap(*i) {+ Some(n) => *i = n,+ None => ok2 = false,+ };+ match self {+ Coincident { p, q } | HorizontalPoints { p, q } | VerticalPoints { p, q } => {+ fp(p);+ fp(q);+ }+ Distance { p, q, .. } | DistanceX { p, q, .. } | DistanceY { p, q, .. } => {+ fp(p);+ fp(q);+ }+ PointOnCurve { p, c } => {+ fp(p);+ fc(c);+ }+ Horizontal { l } | Vertical { l } | Length { l, .. } => fc(l),+ Radius { c, .. } | Diameter { c, .. } => fc(c),+ Parallel { a, b } | Perpendicular { a, b } | Collinear { a, b } | Tangent { a, b } | Equal { a, b } | Concentric { a, b } => {+ fc(a);+ fc(b);+ }+ Angle { a, b, .. } => {+ fc(a);+ fc(b);+ }+ Midpoint { p, l } | PointLineDistance { p, l, .. } => {+ fp(p);+ fc(l);+ }+ Symmetric { p, q, l } => {+ fp(p);+ fp(q);+ fc(l);+ }+ Fix { p } => fp(p),+ }+ ok && ok2+ }+}++#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+pub struct Constraint {+ pub id: String,+ #[serde(flatten)]+ pub kind: ConstraintKind,+ /// For dimensions: the model parameter that drives the value (e.g. `d1`).+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub param: Option<String>,+}++/// A 2D sketch. Point 0 is always the fixed sketch origin (id `origin`).+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+pub struct Sketch {+ pub points: Vec<SPoint>,+ pub curves: Vec<Curve>,+ pub constraints: Vec<Constraint>,+ #[serde(default)]+ next_id: u64,+}++impl Default for Sketch {+ fn default() -> Self {+ Sketch::new()+ }+}++impl Sketch {+ pub fn new() -> Self {+ Sketch { points: vec![SPoint { id: "origin".into(), pos: Vec2::ZERO, fixed: true }], curves: Vec::new(), constraints: Vec::new(), next_id: 1 }+ }++ fn fresh(&mut self, prefix: &str) -> String {+ loop {+ let id = format!("{prefix}{}", self.next_id);+ self.next_id += 1;+ if !self.id_taken(&id) {+ return id;+ }+ }+ }+ fn id_taken(&self, id: &str) -> bool {+ self.points.iter().any(|p| p.id == id) || self.curves.iter().any(|c| c.id == id) || self.constraints.iter().any(|c| c.id == id)+ }++ pub fn point_index(&self, id: &str) -> Option<usize> {+ self.points.iter().position(|p| p.id == id)+ }+ pub fn curve_index(&self, id: &str) -> Option<usize> {+ self.curves.iter().position(|c| c.id == id)+ }+ pub fn point(&self, i: usize) -> Option<Vec2> {+ self.points.get(i).map(|p| p.pos)+ }++ fn check_pos(p: Vec2) -> Result<Vec2> {+ if p.is_finite() && p.x.abs() < 1e9 && p.y.abs() < 1e9 { Ok(p) } else { Err(SketchError::Invalid(format!("point {:?}", [p.x, p.y]))) }+ }++ /// Add a free point (or reuse an existing one within `merge_tol` of `p` when `merge_tol > 0`).+ pub fn add_point(&mut self, p: Vec2, id: Option<&str>) -> Result<usize> {+ let p = Self::check_pos(p)?;+ if self.points.len() >= MAX_POINTS {+ return Err(SketchError::TooLarge);+ }+ let id = match id {+ Some(i) if self.id_taken(i) => return Err(SketchError::Duplicate(i.into())),+ Some("") => return Err(SketchError::Invalid("empty id".into())),+ Some(i) => i.to_string(),+ None => self.fresh("p"),+ };+ self.points.push(SPoint { id, pos: p, fixed: false });+ Ok(self.points.len() - 1)+ }++ fn curve_id(&mut self, id: Option<&str>, prefix: &str) -> Result<String> {+ match id {+ Some(i) if self.id_taken(i) => Err(SketchError::Duplicate(i.into())),+ Some("") => Err(SketchError::Invalid("empty id".into())),+ Some(i) => Ok(i.into()),+ None => Ok(self.fresh(prefix)),+ }+ }++ /// Endpoint ids of a curve's own points: `<curve>.start`, `.end`, `.center`.+ fn own_point(&mut self, curve: &str, role: &str, p: Vec2) -> Result<usize> {+ let id = format!("{curve}.{role}");+ if self.id_taken(&id) {+ return self.add_point(p, None);+ }+ self.add_point(p, Some(&id))+ }++ /// Line between existing points `a` and `b`.+ pub fn add_line_pts(&mut self, a: usize, b: usize, id: Option<&str>) -> Result<usize> {+ if a >= self.points.len() || b >= self.points.len() || a == b {+ return Err(SketchError::Invalid("line needs two distinct points".into()));+ }+ let id = self.curve_id(id, "l")?;+ self.curves.push(Curve { id, kind: CurveKind::Line { a, b }, construction: false });+ Ok(self.curves.len() - 1)+ }++ /// Line from `p0` to `p1`, reusing given point indices when provided.+ pub fn add_line(&mut self, p0: Vec2, p1: Vec2, a: Option<usize>, b: Option<usize>, id: Option<&str>) -> Result<usize> {+ Self::check_pos(p0)?;+ Self::check_pos(p1)?;+ let id = self.curve_id(id, "l")?;+ let a = match a {+ Some(i) if i < self.points.len() => i,+ _ => self.own_point(&id, "start", p0)?,+ };+ let b = match b {+ Some(i) if i < self.points.len() && i != a => i,+ _ => self.own_point(&id, "end", p1)?,+ };+ self.add_line_pts(a, b, Some(&id))+ }++ pub fn add_circle(&mut self, center: Vec2, r: f64, c: Option<usize>, id: Option<&str>) -> Result<usize> {+ if !(r.is_finite() && r > 1e-9 && r < 1e9) {+ return Err(SketchError::Invalid(format!("radius {r}")));+ }+ let id = self.curve_id(id, "c")?;+ let c = match c {+ Some(i) if i < self.points.len() => i,+ _ => self.own_point(&id, "center", center)?,+ };+ self.curves.push(Curve { id, kind: CurveKind::Circle { c, r }, construction: false });+ Ok(self.curves.len() - 1)+ }++ /// Counter-clockwise arc around `center` from `p0` to `p1` (the end point is projected onto+ /// the circle through `p0`).+ pub fn add_arc(&mut self, center: Vec2, p0: Vec2, p1: Vec2, pts: [Option<usize>; 3], id: Option<&str>) -> Result<usize> {+ let r = center.dist(p0);+ if !(r.is_finite() && r > 1e-9 && r < 1e9) {+ return Err(SketchError::Invalid("degenerate arc".into()));+ }+ let p1 = center + (p1 - center).normalized().ok_or_else(|| SketchError::Invalid("degenerate arc".into()))? * r;+ let id = self.curve_id(id, "a")?;+ let n = self.points.len();+ let c = match pts[0] {+ Some(i) if i < n => i,+ _ => self.own_point(&id, "center", center)?,+ };+ let a = match pts[1] {+ Some(i) if i < n => i,+ _ => self.own_point(&id, "start", p0)?,+ };+ let b = match pts[2] {+ Some(i) if i < n && i != a => i,+ _ => self.own_point(&id, "end", p1)?,+ };+ self.curves.push(Curve { id, kind: CurveKind::Arc { c, a, b }, construction: false });+ Ok(self.curves.len() - 1)+ }++ pub fn add_constraint(&mut self, kind: ConstraintKind, param: Option<String>) -> Result<String> {+ if self.constraints.len() >= MAX_CONSTRAINTS {+ return Err(SketchError::TooLarge);+ }+ self.validate(&kind)?;+ let id = self.fresh("k");+ self.constraints.push(Constraint { id: id.clone(), kind, param });+ Ok(id)+ }++ /// Check indices and entity kinds of a constraint.+ pub fn validate(&self, k: &ConstraintKind) -> Result<()> {+ use ConstraintKind::*;+ let (ps, cs) = k.indices();+ for p in &ps {+ if *p >= self.points.len() {+ return Err(SketchError::Unknown(format!("point #{p}")));+ }+ }+ for c in &cs {+ if *c >= self.curves.len() {+ return Err(SketchError::Unknown(format!("curve #{c}")));+ }+ }+ let is_line = |i: usize| matches!(self.curves.get(i).map(|c| &c.kind), Some(CurveKind::Line { .. }));+ let is_round = |i: usize| matches!(self.curves.get(i).map(|c| &c.kind), Some(CurveKind::Circle { .. } | CurveKind::Arc { .. }));+ let name = |i: usize| self.curves.get(i).map(|c| c.id.clone()).unwrap_or_default();+ let need_line = |i: usize| if is_line(i) { Ok(()) } else { Err(SketchError::WrongKind(name(i), "needs a line".into())) };+ let need_round = |i: usize| if is_round(i) { Ok(()) } else { Err(SketchError::WrongKind(name(i), "needs a circle or arc".into())) };+ match *k {+ Horizontal { l } | Vertical { l } | Length { l, .. } | Midpoint { l, .. } | Symmetric { l, .. } | PointLineDistance { l, .. } => {+ need_line(l)?+ }+ Parallel { a, b } | Perpendicular { a, b } | Collinear { a, b } | Angle { a, b, .. } => {+ need_line(a)?;+ need_line(b)?;+ }+ Radius { c, .. } | Diameter { c, .. } => need_round(c)?,+ Concentric { a, b } => {+ need_round(a)?;+ need_round(b)?;+ }+ Tangent { a, b } => {+ if !(is_round(a) || is_round(b)) {+ return Err(SketchError::WrongKind(name(a), "tangent needs a circle or arc".into()));+ }+ }+ Equal { a, b } => {+ if is_line(a) != is_line(b) {+ return Err(SketchError::WrongKind(name(b), "equal needs two lines or two circles/arcs".into()));+ }+ }+ Coincident { p, q } if p == q => return Err(SketchError::Invalid("a point is always coincident with itself".into())),+ _ => {}+ }+ if let Some(v) = k.value()+ && (!v.is_finite() || v.abs() > 1e9 || (v < 0.0 && !k.is_angle()))+ {+ return Err(SketchError::Invalid(format!("dimension value {v}")));+ }+ Ok(())+ }++ /// Radius of a circle or arc.+ pub fn radius(&self, ci: usize) -> Option<f64> {+ match self.curves.get(ci)?.kind {+ CurveKind::Circle { r, .. } => Some(r),+ CurveKind::Arc { c, a, .. } => Some(self.point(c)?.dist(self.point(a)?)),+ CurveKind::Line { .. } => None,+ }+ }+ pub fn center(&self, ci: usize) -> Option<Vec2> {+ match self.curves.get(ci)?.kind {+ CurveKind::Circle { c, .. } | CurveKind::Arc { c, .. } => self.point(c),+ CurveKind::Line { .. } => None,+ }+ }++ /// Boundary segments of a curve (a circle gives two half arcs).+ pub fn segs(&self, ci: usize) -> Vec<Seg2> {+ let Some(cu) = self.curves.get(ci) else { return Vec::new() };+ match cu.kind {+ CurveKind::Line { a, b } => match (self.point(a), self.point(b)) {+ (Some(a), Some(b)) => vec![Seg2::Line { a, b }],+ _ => Vec::new(),+ },+ CurveKind::Circle { c, r } => match self.point(c) {+ Some(c) => solvecraft_geom::Loop2::circle(c, r).segs,+ None => Vec::new(),+ },+ CurveKind::Arc { c, a, b } => match (self.point(c), self.point(a), self.point(b)) {+ (Some(c), Some(pa), Some(pb)) => {+ let start = (pa - c).angle();+ let mut sweep = (pb - c).angle() - start;+ while sweep <= 1e-12 {+ sweep += std::f64::consts::TAU;+ }+ vec![Seg2::Arc { center: c, radius: c.dist(pa), start, sweep }]+ }+ _ => Vec::new(),+ },+ }+ }++ /// Remove curves (by index) and then any points no longer used by a curve (except the+ /// origin and free points), and constraints that referred to removed entities.+ pub fn remove_curves(&mut self, which: &[usize]) {+ let mut owned: Vec<usize> = Vec::new();+ for (i, c) in self.curves.iter().enumerate() {+ if which.contains(&i) {+ match c.kind {+ CurveKind::Line { a, b } => owned.extend([a, b]),+ CurveKind::Circle { c, .. } => owned.push(c),+ CurveKind::Arc { c, a, b } => owned.extend([c, a, b]),+ }+ }+ }+ self.drop_curves(which);+ let mut orphans: Vec<usize> = owned.into_iter().filter(|p| *p != 0 && !self.point_used_by_curve(*p)).collect();+ orphans.sort_unstable();+ orphans.dedup();+ self.remove_points(&orphans);+ }++ fn point_used_by_curve(&self, p: usize) -> bool {+ self.curves.iter().any(|c| match c.kind {+ CurveKind::Line { a, b } => a == p || b == p,+ CurveKind::Circle { c, .. } => c == p,+ CurveKind::Arc { c, a, b } => c == p || a == p || b == p,+ })+ }++ /// Remove curves only (points stay), remapping constraints.+ fn drop_curves(&mut self, which: &[usize]) {+ let mut cmap = vec![None; self.curves.len()];+ let mut n = 0;+ for (i, slot) in cmap.iter_mut().enumerate() {+ if !which.contains(&i) {+ *slot = Some(n);+ n += 1;+ }+ }+ let mut idx = 0;+ self.curves.retain(|_| {+ let k = !which.contains(&idx);+ idx += 1;+ k+ });+ let cm = |i: usize| cmap.get(i).copied().flatten();+ let pm = |i: usize| Some(i);+ self.constraints.retain_mut(|c| c.kind.remap(&pm, &cm));+ }++ /// Remove points (never the origin) and every curve/constraint using them.+ pub fn remove_points(&mut self, which: &[usize]) {+ if which.is_empty() {+ return;+ }+ let gone = |p: usize| p != 0 && which.contains(&p);+ let dead_curves: Vec<usize> = self+ .curves+ .iter()+ .enumerate()+ .filter(|(_, c)| match c.kind {+ CurveKind::Line { a, b } => gone(a) || gone(b),+ CurveKind::Circle { c, .. } => gone(c),+ CurveKind::Arc { c, a, b } => gone(c) || gone(a) || gone(b),+ })+ .map(|(i, _)| i)+ .collect();+ self.drop_curves(&dead_curves);+ let mut pmap = vec![None; self.points.len()];+ let mut n = 0;+ for (i, slot) in pmap.iter_mut().enumerate() {+ if !gone(i) {+ *slot = Some(n);+ n += 1;+ }+ }+ let pm = |i: usize| pmap.get(i).copied().flatten();+ for c in &mut self.curves {+ match &mut c.kind {+ CurveKind::Line { a, b } => {+ *a = pm(*a).unwrap_or(0);+ *b = pm(*b).unwrap_or(0);+ }+ CurveKind::Circle { c, .. } => *c = pm(*c).unwrap_or(0),+ CurveKind::Arc { c, a, b } => {+ *c = pm(*c).unwrap_or(0);+ *a = pm(*a).unwrap_or(0);+ *b = pm(*b).unwrap_or(0);+ }+ }+ }+ let cm = |i: usize| Some(i);+ self.constraints.retain_mut(|c| c.kind.remap(&pm, &cm));+ let mut idx = 0;+ self.points.retain(|_| {+ let k = !gone(idx);+ idx += 1;+ k+ });+ }++ /// Resolve a point reference: a point id (`origin`, `l1.end`, `p3`) or `<curve>.start|end|center`.+ pub fn resolve_point(&self, r: &str) -> Option<usize> {+ if let Some(i) = self.point_index(r) {+ return Some(i);+ }+ let (cid, role) = r.rsplit_once('.')?;+ let c = self.curves.get(self.curve_index(cid)?)?;+ match (&c.kind, role) {+ (CurveKind::Line { a, .. }, "start") | (CurveKind::Arc { a, .. }, "start") => Some(*a),+ (CurveKind::Line { b, .. }, "end") | (CurveKind::Arc { b, .. }, "end") => Some(*b),+ (CurveKind::Circle { c, .. }, "center") | (CurveKind::Arc { c, .. }, "center") => Some(*c),+ _ => None,+ }+ }++ /// Axis-aligned bounds of all geometry (for views).+ pub fn bounds(&self) -> Option<(Vec2, Vec2)> {+ let mut lo = Vec2::new(f64::INFINITY, f64::INFINITY);+ let mut hi = Vec2::new(f64::NEG_INFINITY, f64::NEG_INFINITY);+ let mut any = false;+ for i in 0..self.curves.len() {+ for s in self.segs(i) {+ for p in s.polyline(0.5) {+ lo = Vec2::new(lo.x.min(p.x), lo.y.min(p.y));+ hi = Vec2::new(hi.x.max(p.x), hi.y.max(p.y));+ any = true;+ }+ }+ }+ any.then_some((lo, hi))+ }+}diff --git a/crates/sketch/src/profiles.rs b/crates/sketch/src/profiles.rsnew file mode 100644index 0000000000..20d32cffcc--- /dev/null+++ b/crates/sketch/src/profiles.rs@@ -0,0 +1,273 @@+//! Closed-profile detection.+//!+//! Non-construction lines and arcs form a planar graph (end points within a small tolerance are+//! merged). Dangling edges are pruned, then faces are traced with the "first clockwise turn"+//! rule, which yields every bounded region counter-clockwise. Circles are loops of their own.+//! A loop that lies inside another loop of a different connected component becomes a hole of+//! the innermost loop containing it, so a circle inside a rectangle gives two profiles: the+//! rectangle with a hole, and the disc.++use std::f64::consts::TAU;++use serde::{Deserialize, Serialize};+use solvecraft_geom::{Loop2, Region2, Seg2, Vec2};++use crate::model::{CurveKind, Sketch};++const MERGE_TOL: f64 = 1e-6;+const MAX_EDGES: usize = 50_000;++/// A closed region usable by features, with the ids of the curves bounding it.+#[derive(Clone, Debug, Serialize, Deserialize)]+pub struct Profile {+ pub region: Region2,+ /// Curve ids of the outer loop.+ pub outer_curves: Vec<String>,+ /// Curve ids of each hole loop.+ pub hole_curves: Vec<Vec<String>>,+ pub area: f64,+ pub centroid: Vec2,+}++impl Profile {+ /// All curve ids bounding the profile.+ pub fn curve_ids(&self) -> Vec<String> {+ let mut v = self.outer_curves.clone();+ for h in &self.hole_curves {+ v.extend(h.iter().cloned());+ }+ v+ }+}++struct Edge {+ curve: usize,+ seg: Seg2,+ u: usize,+ v: usize,+}++fn find(p: &mut [usize], mut i: usize) -> usize {+ while let Some(&q) = p.get(i) {+ if q == i {+ break;+ }+ i = q;+ }+ i+}++/// Find all closed profiles of a sketch.+pub fn find_profiles(sk: &Sketch) -> Vec<Profile> {+ // Node ids: point indices merged by position.+ let n = sk.points.len();+ let mut parent: Vec<usize> = (0..n).collect();+ let mut order: Vec<usize> = (0..n).collect();+ order.sort_by(|a, b| {+ let (pa, pb) = (sk.points.get(*a).map(|p| p.pos.x).unwrap_or(0.0), sk.points.get(*b).map(|p| p.pos.x).unwrap_or(0.0));+ pa.total_cmp(&pb)+ });+ for (k, &i) in order.iter().enumerate() {+ let Some(pi) = sk.points.get(i).map(|p| p.pos) else { continue };+ for &j in order.iter().skip(k + 1) {+ let Some(pj) = sk.points.get(j).map(|p| p.pos) else { continue };+ if pj.x - pi.x > MERGE_TOL {+ break;+ }+ if pi.dist(pj) <= MERGE_TOL {+ let (ri, rj) = (find(&mut parent, i), find(&mut parent, j));+ if ri != rj+ && let Some(s) = parent.get_mut(rj)+ {+ *s = ri;+ }+ }+ }+ }++ let mut loops: Vec<(Loop2, Vec<String>, usize)> = Vec::new(); // (ccw loop, curve ids, component)+ let mut edges: Vec<Edge> = Vec::new();+ for (ci, c) in sk.curves.iter().enumerate() {+ if c.construction {+ continue;+ }+ match c.kind {+ CurveKind::Circle { .. } => {+ let segs = sk.segs(ci);+ if !segs.is_empty() {+ loops.push((Loop2 { segs }, vec![c.id.clone()], usize::MAX - ci));+ }+ }+ CurveKind::Line { a, b } | CurveKind::Arc { a, b, .. } => {+ let (u, v) = (find(&mut parent, a), find(&mut parent, b));+ if u == v {+ continue;+ }+ if let Some(seg) = sk.segs(ci).into_iter().next()+ && seg.length() > MERGE_TOL+ {+ edges.push(Edge { curve: ci, seg, u, v });+ }+ }+ }+ if edges.len() > MAX_EDGES {+ break;+ }+ }++ // Prune dangling edges.+ let mut alive = vec![true; edges.len()];+ loop {+ let mut deg = vec![0usize; n];+ for (e, a) in edges.iter().zip(&alive) {+ if *a {+ if let Some(d) = deg.get_mut(e.u) {+ *d += 1;+ }+ if let Some(d) = deg.get_mut(e.v) {+ *d += 1;+ }+ }+ }+ let mut changed = false;+ for (e, a) in edges.iter().zip(alive.iter_mut()) {+ if *a && (deg.get(e.u).copied().unwrap_or(0) < 2 || deg.get(e.v).copied().unwrap_or(0) < 2) {+ *a = false;+ changed = true;+ }+ }+ if !changed {+ break;+ }+ }++ // Components over nodes for nesting.+ let mut comp: Vec<usize> = (0..n).collect();+ for (e, a) in edges.iter().zip(&alive) {+ if *a {+ let (ru, rv) = (find(&mut comp, e.u), find(&mut comp, e.v));+ if ru != rv+ && let Some(s) = comp.get_mut(rv)+ {+ *s = ru;+ }+ }+ }++ // Half-edges: 2e = forward (u→v), 2e+1 = backward.+ let half = |h: usize| -> Option<(Seg2, usize, usize)> {+ let e = edges.get(h / 2)?;+ Some(if h.is_multiple_of(2) { (e.seg, e.u, e.v) } else { (e.seg.reversed(), e.v, e.u) })+ };+ let mut outgoing: Vec<Vec<usize>> = vec![Vec::new(); n];+ for (ei, a) in alive.iter().enumerate() {+ if !*a {+ continue;+ }+ for h in [2 * ei, 2 * ei + 1] {+ if let Some((_, from, _)) = half(h)+ && let Some(o) = outgoing.get_mut(from)+ {+ o.push(h);+ }+ }+ }+ let mut visited = vec![false; edges.len() * 2];+ for start in 0..edges.len() * 2 {+ if !alive.get(start / 2).copied().unwrap_or(false) || visited.get(start).copied().unwrap_or(true) {+ continue;+ }+ let mut segs = Vec::new();+ let mut ids = Vec::new();+ let mut h = start;+ let mut ok = true;+ for _ in 0..=edges.len() * 2 {+ if let Some(v) = visited.get_mut(h) {+ *v = true;+ }+ let Some((seg, _, to)) = half(h) else {+ ok = false;+ break;+ };+ segs.push(seg);+ if let Some(e) = edges.get(h / 2)+ && let Some(c) = sk.curves.get(e.curve)+ {+ ids.push(c.id.clone());+ }+ let back = (-seg.end_tangent()).angle();+ let twin = h ^ 1;+ let mut best: Option<(f64, usize)> = None;+ for &o in outgoing.get(to).map(Vec::as_slice).unwrap_or(&[]) {+ if o == twin {+ continue;+ }+ let Some((os, _, _)) = half(o) else { continue };+ let mut d = (back - os.start_tangent().angle()) % TAU;+ if d <= 1e-12 {+ d += TAU;+ }+ if best.is_none_or(|(bd, _)| d < bd) {+ best = Some((d, o));+ }+ }+ let Some((_, next)) = best else {+ ok = false;+ break;+ };+ h = next;+ if h == start {+ break;+ }+ if visited.get(h).copied().unwrap_or(true) {+ ok = false;+ break;+ }+ }+ if !ok || h != start {+ continue;+ }+ let lp = Loop2 { segs };+ if lp.signed_area() > 1e-9 {+ let c = edges.get(start / 2).map(|e| find(&mut comp, e.u)).unwrap_or(0);+ loops.push((lp, ids, c));+ }+ }++ // Nesting: parent = smallest containing loop from another component.+ let areas: Vec<f64> = loops.iter().map(|(l, _, _)| l.signed_area().abs()).collect();+ let mut parent_of: Vec<Option<usize>> = vec![None; loops.len()];+ for (i, (li, _, ci)) in loops.iter().enumerate() {+ let probe = li.segs.first().map(Seg2::mid).unwrap_or_default();+ let ai = areas.get(i).copied().unwrap_or(0.0);+ let mut best: Option<(f64, usize)> = None;+ for (j, (lj, _, cj)) in loops.iter().enumerate() {+ let aj = areas.get(j).copied().unwrap_or(0.0);+ if i == j || ci == cj || aj <= ai {+ continue;+ }+ if lj.contains(probe) && best.is_none_or(|(ba, _)| aj < ba) {+ best = Some((aj, j));+ }+ }+ if let Some(p) = parent_of.get_mut(i) {+ *p = best.map(|(_, j)| j);+ }+ }+ let mut out: Vec<Profile> = loops+ .iter()+ .enumerate()+ .map(|(i, (l, ids, _))| {+ let kids: Vec<usize> = (0..loops.len()).filter(|k| parent_of.get(*k).copied().flatten() == Some(i)).collect();+ let holes: Vec<Loop2> = kids.iter().filter_map(|k| loops.get(*k).map(|(h, _, _)| h.ccw().reversed())).collect();+ let hole_curves: Vec<Vec<String>> = kids.iter().filter_map(|k| loops.get(*k).map(|(_, ids, _)| ids.clone())).collect();+ let region = Region2 { outer: l.ccw(), holes };+ let area = region.area();+ let centroid = region.centroid();+ Profile { region, outer_curves: ids.clone(), hole_curves, area, centroid }+ })+ .collect();+ let first_curve = |p: &Profile| p.outer_curves.iter().filter_map(|id| sk.curve_index(id)).min().unwrap_or(usize::MAX);+ out.sort_by(|a, b| first_curve(a).cmp(&first_curve(b)).then(b.area.total_cmp(&a.area)));+ out+}diff --git a/crates/sketch/src/solver.rs b/crates/sketch/src/solver.rsnew file mode 100644index 0000000000..33a52f7884--- /dev/null+++ b/crates/sketch/src/solver.rs@@ -0,0 +1,636 @@+//! The constraint solver.+//!+//! Unknowns are the coordinates of every non-fixed point and the radius of every circle. Each+//! constraint contributes residuals (zero when satisfied, in millimetres so that all rows have a+//! comparable scale). The system is split into connected components and each is solved with a+//! damped Gauss–Newton (Levenberg–Marquardt) iteration on a dense Jacobian built from local+//! central differences. Small steps from the current positions are preferred, so+//! under-constrained sketches move as little as possible. Afterwards the rank of the Jacobian+//! gives the remaining degrees of freedom and which points are fully determined.++use serde::{Deserialize, Serialize};+use solvecraft_geom::Vec2;++use crate::linalg::{Mat, determined_vars, solve as lin_solve};+use crate::model::{ConstraintKind, CurveKind, Sketch};++const MAX_ITERS: usize = 200;+/// Converged when every residual is below this (mm).+const TOL: f64 = 1e-9;+/// A solution is accepted when every residual is below this (mm).+const ACCEPT: f64 = 1e-6;++#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]+#[serde(rename_all = "snake_case")]+pub enum SolveStatus {+ /// All constraints satisfied.+ Solved,+ /// The constraints conflict (or the solver could not satisfy them); geometry was left as it+ /// was before solving.+ Failed,+}++#[derive(Clone, Debug, Serialize, Deserialize)]+pub struct SolveReport {+ pub status: SolveStatus,+ /// Remaining degrees of freedom (0 = fully constrained).+ pub dof: usize,+ pub iterations: usize,+ pub max_residual: f64,+ /// Constraints still violated after a failed solve.+ pub failing: Vec<String>,+ /// Per point: fully determined by constraints (fixed points count as determined).+ pub point_determined: Vec<bool>,+ /// Per curve: all of its defining values determined.+ pub curve_determined: Vec<bool>,+}++impl SolveReport {+ pub fn ok(&self) -> bool {+ self.status == SolveStatus::Solved+ }+ pub fn fully_constrained(&self) -> bool {+ self.dof == 0+ }+}++/// Variable layout: point → (x var, y var), circle → radius var.+struct Layout {+ pvar: Vec<Option<usize>>,+ rvar: Vec<Option<usize>>,+ n: usize,+}++fn layout(sk: &Sketch) -> Layout {+ let mut fixed: Vec<bool> = sk.points.iter().map(|p| p.fixed).collect();+ for c in &sk.constraints {+ if let ConstraintKind::Fix { p } = c.kind+ && let Some(f) = fixed.get_mut(p)+ {+ *f = true;+ }+ }+ let mut n = 0;+ let pvar = fixed+ .iter()+ .map(|f| {+ if *f {+ None+ } else {+ n += 2;+ Some(n - 2)+ }+ })+ .collect();+ let rvar = sk+ .curves+ .iter()+ .map(|c| match c.kind {+ CurveKind::Circle { .. } => {+ n += 1;+ Some(n - 1)+ }+ _ => None,+ })+ .collect();+ Layout { pvar, rvar, n }+}++/// Read-only view of the sketch with variable values substituted.+struct State<'a> {+ sk: &'a Sketch,+ lay: &'a Layout,+ x: &'a [f64],+}++impl State<'_> {+ fn p(&self, i: usize) -> Vec2 {+ match self.lay.pvar.get(i).copied().flatten() {+ Some(v) => Vec2::new(self.x.get(v).copied().unwrap_or(0.0), self.x.get(v + 1).copied().unwrap_or(0.0)),+ None => self.sk.points.get(i).map(|p| p.pos).unwrap_or_default(),+ }+ }+ fn line(&self, l: usize) -> (Vec2, Vec2) {+ match self.sk.curves.get(l).map(|c| &c.kind) {+ Some(CurveKind::Line { a, b }) => (self.p(*a), self.p(*b)),+ _ => (Vec2::ZERO, Vec2::X),+ }+ }+ /// Centre and radius of a circle or arc.+ fn round(&self, c: usize) -> (Vec2, f64) {+ match self.sk.curves.get(c).map(|c| &c.kind) {+ Some(CurveKind::Circle { c: ci, r }) => {+ let r = match self.lay.rvar.get(c).copied().flatten() {+ Some(v) => self.x.get(v).copied().unwrap_or(*r),+ None => *r,+ };+ (self.p(*ci), r)+ }+ Some(CurveKind::Arc { c: ci, a, .. }) => {+ let cc = self.p(*ci);+ (cc, cc.dist(self.p(*a)))+ }+ _ => (Vec2::ZERO, 0.0),+ }+ }+ fn is_line(&self, c: usize) -> bool {+ matches!(self.sk.curves.get(c).map(|c| &c.kind), Some(CurveKind::Line { .. }))+ }+}++fn wrap_angle(a: f64) -> f64 {+ let t = std::f64::consts::TAU;+ let mut a = a % t;+ if a > std::f64::consts::PI {+ a -= t;+ } else if a <= -std::f64::consts::PI {+ a += t;+ }+ a+}++/// Distance from `p` to the infinite line through `a`, `b` (signed by side).+fn line_dist(p: Vec2, a: Vec2, b: Vec2) -> f64 {+ let d = b - a;+ let l = d.len().max(1e-12);+ d.cross(p - a) / l+}++/// Residual rows of one constraint.+fn residuals(s: &State, k: &ConstraintKind, out: &mut Vec<f64>) {+ use ConstraintKind::*;+ match *k {+ Coincident { p, q } => {+ let d = s.p(p) - s.p(q);+ out.extend([d.x, d.y]);+ }+ PointOnCurve { p, c } => {+ let pp = s.p(p);+ if s.is_line(c) {+ let (a, b) = s.line(c);+ out.push(line_dist(pp, a, b));+ } else {+ let (cc, r) = s.round(c);+ out.push(pp.dist(cc) - r);+ }+ }+ Horizontal { l } => {+ let (a, b) = s.line(l);+ out.push(b.y - a.y);+ }+ Vertical { l } => {+ let (a, b) = s.line(l);+ out.push(b.x - a.x);+ }+ HorizontalPoints { p, q } => out.push(s.p(q).y - s.p(p).y),+ VerticalPoints { p, q } => out.push(s.p(q).x - s.p(p).x),+ Parallel { a, b } | Perpendicular { a, b } => {+ let (a0, a1) = s.line(a);+ let (b0, b1) = s.line(b);+ let (da, db) = (a1 - a0, b1 - b0);+ let scale = (da.len() + db.len()).max(1e-12);+ let v = if matches!(k, Parallel { .. }) { da.cross(db) } else { da.dot(db) };+ out.push(v / scale);+ }+ Collinear { a, b } => {+ let (a0, a1) = s.line(a);+ let (b0, b1) = s.line(b);+ out.push(line_dist(b0, a0, a1));+ out.push(line_dist(b1, a0, a1));+ }+ Tangent { a, b } => {+ let (la, lb) = (s.is_line(a), s.is_line(b));+ if la || lb {+ let (l, c) = if la { (a, b) } else { (b, a) };+ let (p0, p1) = s.line(l);+ let (cc, r) = s.round(c);+ out.push(line_dist(cc, p0, p1).abs() - r);+ } else {+ let (c1, r1) = s.round(a);+ let (c2, r2) = s.round(b);+ let d = c1.dist(c2);+ let ext = d - (r1 + r2);+ let int = d - (r1 - r2).abs();+ out.push(if ext.abs() <= int.abs() { ext } else { int });+ }+ }+ Equal { a, b } => {+ if s.is_line(a) {+ let (a0, a1) = s.line(a);+ let (b0, b1) = s.line(b);+ out.push(a0.dist(a1) - b0.dist(b1));+ } else {+ out.push(s.round(a).1 - s.round(b).1);+ }+ }+ Concentric { a, b } => {+ let d = s.round(a).0 - s.round(b).0;+ out.extend([d.x, d.y]);+ }+ Midpoint { p, l } => {+ let (a, b) = s.line(l);+ let d = s.p(p) - (a + b) * 0.5;+ out.extend([d.x, d.y]);+ }+ Symmetric { p, q, l } => {+ let (a, b) = s.line(l);+ let (pp, qq) = (s.p(p), s.p(q));+ let dir = b - a;+ let len = dir.len().max(1e-12);+ out.push(line_dist((pp + qq) * 0.5, a, b));+ out.push((qq - pp).dot(dir) / len);+ }+ Fix { .. } => {}+ Distance { p, q, value } => out.push(s.p(p).dist(s.p(q)) - value),+ DistanceX { p, q, value } => out.push((s.p(q).x - s.p(p).x).abs() - value),+ DistanceY { p, q, value } => out.push((s.p(q).y - s.p(p).y).abs() - value),+ PointLineDistance { p, l, value } => {+ let (a, b) = s.line(l);+ out.push(line_dist(s.p(p), a, b).abs() - value);+ }+ Length { l, value } => {+ let (a, b) = s.line(l);+ out.push(a.dist(b) - value);+ }+ Radius { c, value } => out.push(s.round(c).1 - value),+ Diameter { c, value } => out.push(2.0 * s.round(c).1 - value),+ Angle { a, b, value } => {+ let (a0, a1) = s.line(a);+ let (b0, b1) = s.line(b);+ let (da, db) = (a1 - a0, b1 - b0);+ let ang = da.cross(db).atan2(da.dot(db));+ let scale = 0.5 * (da.len() + db.len());+ out.push(wrap_angle(ang - value) * scale.max(1e-6));+ }+ }+}++/// One residual block: implicit arc radius equality or a user constraint.+enum Block<'a> {+ Arc { c: usize, a: usize, b: usize },+ User(usize, &'a ConstraintKind),+}++fn block_residuals(s: &State, b: &Block, out: &mut Vec<f64>) {+ match b {+ Block::Arc { c, a, b } => {+ let cc = s.p(*c);+ out.push(cc.dist(s.p(*b)) - cc.dist(s.p(*a)));+ }+ Block::User(_, k) => residuals(s, k, out),+ }+}++/// Variables a block depends on.+fn block_vars(sk: &Sketch, lay: &Layout, b: &Block) -> Vec<usize> {+ let mut v = Vec::new();+ let pt = |v: &mut Vec<usize>, p: usize| {+ if let Some(x) = lay.pvar.get(p).copied().flatten() {+ v.extend([x, x + 1]);+ }+ };+ let curve = |v: &mut Vec<usize>, c: usize| match sk.curves.get(c).map(|c| &c.kind) {+ Some(CurveKind::Line { a, b }) => {+ pt(v, *a);+ pt(v, *b);+ }+ Some(CurveKind::Circle { c: ci, .. }) => {+ pt(v, *ci);+ if let Some(r) = lay.rvar.get(c).copied().flatten() {+ v.push(r);+ }+ }+ Some(CurveKind::Arc { c, a, b }) => {+ pt(v, *c);+ pt(v, *a);+ pt(v, *b);+ }+ None => {}+ };+ use ConstraintKind::*;+ match b {+ Block::Arc { c, a, b } => {+ pt(&mut v, *c);+ pt(&mut v, *a);+ pt(&mut v, *b);+ }+ Block::User(_, k) => match **k {+ Coincident { p, q } | HorizontalPoints { p, q } | VerticalPoints { p, q } => {+ pt(&mut v, p);+ pt(&mut v, q);+ }+ Distance { p, q, .. } | DistanceX { p, q, .. } | DistanceY { p, q, .. } => {+ pt(&mut v, p);+ pt(&mut v, q);+ }+ PointOnCurve { p, c } | Midpoint { p, l: c } | PointLineDistance { p, l: c, .. } => {+ pt(&mut v, p);+ curve(&mut v, c);+ }+ Horizontal { l } | Vertical { l } | Length { l, .. } | Radius { c: l, .. } | Diameter { c: l, .. } => curve(&mut v, l),+ Parallel { a, b }+ | Perpendicular { a, b }+ | Collinear { a, b }+ | Tangent { a, b }+ | Equal { a, b }+ | Concentric { a, b }+ | Angle { a, b, .. } => {+ curve(&mut v, a);+ curve(&mut v, b);+ }+ Symmetric { p, q, l } => {+ pt(&mut v, p);+ pt(&mut v, q);+ curve(&mut v, l);+ }+ Fix { .. } => {}+ },+ }+ v.sort_unstable();+ v.dedup();+ v+}++fn find(parent: &mut [usize], mut i: usize) -> usize {+ while let Some(&p) = parent.get(i) {+ if p == i {+ break;+ }+ let gp = parent.get(p).copied().unwrap_or(p);+ if let Some(slot) = parent.get_mut(i) {+ *slot = gp;+ }+ i = p;+ }+ i+}++/// Residual vector and Jacobian (rows × all n vars) for the given blocks.+fn system(sk: &Sketch, lay: &Layout, blocks: &[(Block, Vec<usize>)], x: &mut [f64], with_j: bool) -> (Vec<f64>, Option<Mat>, Vec<usize>) {+ let mut r = Vec::new();+ let mut owner = Vec::new();+ for (bi, (b, _)) in blocks.iter().enumerate() {+ let before = r.len();+ block_residuals(&State { sk, lay, x }, b, &mut r);+ owner.extend(std::iter::repeat_n(bi, r.len() - before));+ }+ if !with_j {+ return (r, None, owner);+ }+ let mut j = Mat::zeros(r.len(), lay.n);+ let mut row = 0;+ let mut plus = Vec::new();+ let mut minus = Vec::new();+ for (b, vars) in blocks {+ plus.clear();+ block_residuals(&State { sk, lay, x }, b, &mut plus);+ let rows = plus.len();+ for &v in vars {+ let Some(x0) = x.get(v).copied() else { continue };+ let h = 1e-7 * x0.abs().max(1.0);+ if let Some(xv) = x.get_mut(v) {+ *xv = x0 + h;+ }+ plus.clear();+ block_residuals(&State { sk, lay, x }, b, &mut plus);+ if let Some(xv) = x.get_mut(v) {+ *xv = x0 - h;+ }+ minus.clear();+ block_residuals(&State { sk, lay, x }, b, &mut minus);+ if let Some(xv) = x.get_mut(v) {+ *xv = x0;+ }+ for k in 0..rows {+ let d = (plus.get(k).copied().unwrap_or(0.0) - minus.get(k).copied().unwrap_or(0.0)) / (2.0 * h);+ j.set(row + k, v, d);+ }+ }+ row += rows;+ }+ (r, Some(j), owner)+}++fn max_abs(v: &[f64]) -> f64 {+ v.iter().fold(0.0_f64, |m, x| if x.is_finite() { m.max(x.abs()) } else { f64::INFINITY })+}+fn norm2(v: &[f64]) -> f64 {+ v.iter().map(|x| x * x).sum()+}++/// Levenberg–Marquardt on one component (variables `vars`, blocks `blocks`). Returns iterations.+fn lm(sk: &Sketch, lay: &Layout, blocks: &[(Block, Vec<usize>)], vars: &[usize], x: &mut Vec<f64>) -> usize {+ let n = vars.len();+ let mut lambda = 1e-3;+ let (mut r, _, _) = system(sk, lay, blocks, x, false);+ let mut f = norm2(&r);+ for it in 0..MAX_ITERS {+ if max_abs(&r) < TOL {+ return it;+ }+ let (_, Some(j), _) = system(sk, lay, blocks, x, true) else { return it };+ // Normal equations restricted to this component's variables.+ let mut a = Mat::zeros(n, n);+ let mut g = vec![0.0; n];+ for row in 0..j.rows {+ let ri = r.get(row).copied().unwrap_or(0.0);+ let nz: Vec<(usize, f64)> = vars.iter().enumerate().map(|(li, &v)| (li, j.get(row, v))).filter(|(_, d)| *d != 0.0).collect();+ for &(li, di) in &nz {+ if let Some(gi) = g.get_mut(li) {+ *gi += di * ri;+ }+ for &(lk, dk) in &nz {+ a.add(li, lk, di * dk);+ }+ }+ }+ let mut improved = false;+ for _ in 0..30 {+ let mut m = a.clone();+ for i in 0..n {+ let d = a.get(i, i);+ m.add(i, i, lambda * (d + 1e-9) + 1e-12);+ }+ let rhs: Vec<f64> = g.iter().map(|v| -v).collect();+ let Some(step) = lin_solve(m, rhs) else {+ lambda *= 10.0;+ continue;+ };+ let mut trial = x.clone();+ for (li, &v) in vars.iter().enumerate() {+ if let (Some(t), Some(s)) = (trial.get_mut(v), step.get(li)) {+ *t += s;+ }+ }+ let (rt, _, _) = system(sk, lay, blocks, &mut trial, false);+ let ft = norm2(&rt);+ if ft.is_finite() && ft < f {+ *x = trial;+ r = rt;+ f = ft;+ lambda = (lambda / 3.0).max(1e-12);+ improved = true;+ break;+ }+ lambda *= 4.0;+ if lambda > 1e12 {+ break;+ }+ }+ if !improved {+ return it;+ }+ }+ MAX_ITERS+}++/// Solve the sketch in place. On failure the geometry is restored and the report lists the+/// violated constraints.+pub fn solve(sk: &mut Sketch) -> SolveReport {+ let lay = layout(sk);+ let mut x = vec![0.0; lay.n];+ for (i, p) in sk.points.iter().enumerate() {+ if let Some(v) = lay.pvar.get(i).copied().flatten() {+ if let Some(s) = x.get_mut(v) {+ *s = p.pos.x;+ }+ if let Some(s) = x.get_mut(v + 1) {+ *s = p.pos.y;+ }+ }+ }+ for (i, c) in sk.curves.iter().enumerate() {+ if let (CurveKind::Circle { r, .. }, Some(v)) = (&c.kind, lay.rvar.get(i).copied().flatten())+ && let Some(s) = x.get_mut(v)+ {+ *s = *r;+ }+ }+ let x0 = x.clone();++ let mut blocks: Vec<(Block, Vec<usize>)> = Vec::new();+ for c in &sk.curves {+ if let CurveKind::Arc { c, a, b } = c.kind {+ let bl = Block::Arc { c, a, b };+ let vars = block_vars(sk, &lay, &bl);+ blocks.push((bl, vars));+ }+ }+ for (i, c) in sk.constraints.iter().enumerate() {+ let bl = Block::User(i, &c.kind);+ let vars = block_vars(sk, &lay, &bl);+ blocks.push((bl, vars));+ }++ // Connected components over variables.+ let mut parent: Vec<usize> = (0..lay.n).collect();+ for (_, vars) in &blocks {+ if let Some(&first) = vars.first() {+ for &v in vars.iter().skip(1) {+ let (ra, rb) = (find(&mut parent, first), find(&mut parent, v));+ if let Some(p) = parent.get_mut(ra) {+ *p = rb;+ }+ }+ }+ }+ let mut comps: Vec<(usize, Vec<usize>, Vec<usize>)> = Vec::new(); // (root, vars, block idx)+ for v in 0..lay.n {+ let r = find(&mut parent, v);+ match comps.iter_mut().find(|c| c.0 == r) {+ Some(c) => c.1.push(v),+ None => comps.push((r, vec![v], Vec::new())),+ }+ }+ let mut constant_blocks = Vec::new();+ for (bi, (_, vars)) in blocks.iter().enumerate() {+ match vars.first() {+ Some(&v) => {+ let r = find(&mut parent, v);+ if let Some(c) = comps.iter_mut().find(|c| c.0 == r) {+ c.2.push(bi);+ }+ }+ None => constant_blocks.push(bi),+ }+ }++ let mut iterations = 0;+ // Solve each component; `blocks` is consumed by index so rebuild per component.+ let all_blocks = blocks;+ for (_, vars, bis) in &comps {+ if bis.is_empty() {+ continue;+ }+ let sub: Vec<(Block, Vec<usize>)> = bis+ .iter()+ .filter_map(|&bi| {+ all_blocks.get(bi).map(|(b, v)| {+ let b2 = match b {+ Block::Arc { c, a, b } => Block::Arc { c: *c, a: *a, b: *b },+ Block::User(i, k) => Block::User(*i, k),+ };+ (b2, v.clone())+ })+ })+ .collect();+ iterations += lm(sk, &lay, &sub, vars, &mut x);+ }++ // Final residuals, Jacobian and analysis over everything.+ let (r, j, owner) = system(sk, &lay, &all_blocks, &mut x, true);+ let max_residual = max_abs(&r);+ let mut failing: Vec<String> = Vec::new();+ for (row, v) in r.iter().enumerate() {+ if !(v.abs() < ACCEPT)+ && let Some((Block::User(ci, _), _)) = owner.get(row).and_then(|bi| all_blocks.get(*bi))+ && let Some(c) = sk.constraints.get(*ci)+ && !failing.contains(&c.id)+ {+ failing.push(c.id.clone());+ }+ }+ let _ = constant_blocks;+ let status = if max_residual < ACCEPT { SolveStatus::Solved } else { SolveStatus::Failed };+ let use_x = if status == SolveStatus::Solved { &x } else { &x0 };+ let (det, rank) = match &j {+ Some(j) if j.rows > 0 => determined_vars(j, 1e-7),+ _ => (vec![false; lay.n], 0),+ };+ // Write back.+ for (i, p) in sk.points.iter_mut().enumerate() {+ if let Some(v) = lay.pvar.get(i).copied().flatten() {+ p.pos = Vec2::new(use_x.get(v).copied().unwrap_or(p.pos.x), use_x.get(v + 1).copied().unwrap_or(p.pos.y));+ }+ }+ for (i, c) in sk.curves.iter_mut().enumerate() {+ if let (CurveKind::Circle { r, .. }, Some(v)) = (&mut c.kind, lay.rvar.get(i).copied().flatten()) {+ *r = use_x.get(v).copied().unwrap_or(*r).abs().max(1e-9);+ }+ }+ let vdet = |v: Option<usize>| v.is_none_or(|v| det.get(v).copied().unwrap_or(false));+ let pdet = |p: usize| match lay.pvar.get(p).copied().flatten() {+ Some(v) => vdet(Some(v)) && vdet(Some(v + 1)),+ None => true,+ };+ let point_determined: Vec<bool> = (0..sk.points.len()).map(pdet).collect();+ let curve_determined = sk+ .curves+ .iter()+ .enumerate()+ .map(|(i, c)| match c.kind {+ CurveKind::Line { a, b } => pdet(a) && pdet(b),+ CurveKind::Circle { c, .. } => pdet(c) && vdet(lay.rvar.get(i).copied().flatten()),+ CurveKind::Arc { c, a, b } => pdet(c) && pdet(a) && pdet(b),+ })+ .collect();+ SolveReport {+ status,+ dof: lay.n.saturating_sub(rank),+ iterations,+ max_residual: if max_residual.is_finite() { max_residual } else { f64::MAX },+ failing,+ point_determined,+ curve_determined,+ }+}diff --git a/crates/sketch/src/tests.rs b/crates/sketch/src/tests.rsnew file mode 100644index 0000000000..947c4b6758--- /dev/null+++ b/crates/sketch/src/tests.rs@@ -0,0 +1,252 @@+use std::f64::consts::{FRAC_PI_2, PI};++use solvecraft_geom::Vec2;++use crate::*;++fn v(x: f64, y: f64) -> Vec2 {+ Vec2::new(x, y)+}++/// Rough rectangle from four lines sharing corner points.+fn rect(sk: &mut Sketch, p: [Vec2; 4]) -> [usize; 4] {+ let a = sk.add_point(p[0], None).unwrap();+ let b = sk.add_point(p[1], None).unwrap();+ let c = sk.add_point(p[2], None).unwrap();+ let d = sk.add_point(p[3], None).unwrap();+ [+ sk.add_line_pts(a, b, None).unwrap(),+ sk.add_line_pts(b, c, None).unwrap(),+ sk.add_line_pts(c, d, None).unwrap(),+ sk.add_line_pts(d, a, None).unwrap(),+ ]+}++fn line_pts(sk: &Sketch, l: usize) -> (Vec2, Vec2) {+ match sk.curves[l].kind {+ CurveKind::Line { a, b } => (sk.points[a].pos, sk.points[b].pos),+ _ => panic!(),+ }+}++#[test]+fn fully_constrained_rectangle() {+ let mut sk = Sketch::new();+ let l = rect(&mut sk, [v(0.3, -0.2), v(38.0, 1.0), v(41.0, 29.0), v(-1.0, 31.0)]);+ use ConstraintKind::*;+ sk.add_constraint(Horizontal { l: l[0] }, None).unwrap();+ sk.add_constraint(Horizontal { l: l[2] }, None).unwrap();+ sk.add_constraint(Vertical { l: l[1] }, None).unwrap();+ sk.add_constraint(Vertical { l: l[3] }, None).unwrap();+ let (a, _) = match sk.curves[l[0]].kind {+ CurveKind::Line { a, b } => (a, b),+ _ => panic!(),+ };+ sk.add_constraint(Coincident { p: a, q: 0 }, None).unwrap();+ sk.add_constraint(Length { l: l[0], value: 40.0 }, Some("d1".into())).unwrap();+ sk.add_constraint(Length { l: l[1], value: 30.0 }, Some("d2".into())).unwrap();+ let rep = solve(&mut sk);+ assert!(rep.ok(), "{rep:?}");+ assert_eq!(rep.dof, 0, "{rep:?}");+ assert!(rep.point_determined.iter().all(|d| *d));+ let (p0, p1) = line_pts(&sk, l[0]);+ assert!(p0.dist(v(0.0, 0.0)) < 1e-7, "{p0:?}");+ assert!(p1.dist(v(40.0, 0.0)) < 1e-7, "{p1:?}");+ let (_, p2) = line_pts(&sk, l[1]);+ assert!(p2.dist(v(40.0, 30.0)) < 1e-7, "{p2:?}");+ // Change a dimension and re-solve.+ sk.constraints[5].kind.set_value(55.0);+ assert!(solve(&mut sk).ok());+ let (_, p1) = line_pts(&sk, l[0]);+ assert!(p1.dist(v(55.0, 0.0)) < 1e-7);+}++#[test]+fn under_constrained_reports_dof() {+ let mut sk = Sketch::new();+ let l = sk.add_line(v(0.0, 0.0), v(10.0, 1.0), None, None, None).unwrap();+ sk.add_constraint(ConstraintKind::Horizontal { l }, None).unwrap();+ let rep = solve(&mut sk);+ assert!(rep.ok());+ assert_eq!(rep.dof, 3);+ let (a, b) = line_pts(&sk, l);+ assert!((a.y - b.y).abs() < 1e-9);+ // Minimal movement: the line moved by about half a unit each.+ assert!((a.y - 0.5).abs() < 0.05 && (b.y - 0.5).abs() < 0.05, "{a:?} {b:?}");+}++#[test]+fn conflicting_constraints_fail_and_restore() {+ let mut sk = Sketch::new();+ let l = sk.add_line(v(0.0, 0.0), v(10.0, 0.0), None, None, None).unwrap();+ sk.add_constraint(ConstraintKind::Horizontal { l }, None).unwrap();+ sk.add_constraint(ConstraintKind::Vertical { l }, None).unwrap();+ sk.add_constraint(ConstraintKind::Length { l, value: 10.0 }, None).unwrap();+ let before = sk.clone();+ let rep = solve(&mut sk);+ assert_eq!(rep.status, SolveStatus::Failed);+ assert!(!rep.failing.is_empty());+ assert_eq!(sk.points, before.points);+}++#[test]+fn circles_tangent_equal_concentric() {+ let mut sk = Sketch::new();+ let c1 = sk.add_circle(v(0.0, 0.0), 5.0, Some(0), None).unwrap();+ let c2 = sk.add_circle(v(12.0, 1.0), 3.0, None, None).unwrap();+ use ConstraintKind::*;+ sk.add_constraint(Radius { c: c1, value: 10.0 }, None).unwrap();+ sk.add_constraint(Equal { a: c1, b: c2 }, None).unwrap();+ sk.add_constraint(Tangent { a: c1, b: c2 }, None).unwrap();+ let rep = solve(&mut sk);+ assert!(rep.ok(), "{rep:?}");+ assert!((sk.radius(c2).unwrap() - 10.0).abs() < 1e-7);+ assert!((sk.center(c2).unwrap().len() - 20.0).abs() < 1e-7);+ let c3 = sk.add_circle(v(3.0, 3.0), 2.0, None, None).unwrap();+ sk.add_constraint(Concentric { a: c3, b: c2 }, None).unwrap();+ assert!(solve(&mut sk).ok());+ assert!(sk.center(c3).unwrap().dist(sk.center(c2).unwrap()) < 1e-7);+}++#[test]+fn line_tangent_to_circle_and_angles() {+ let mut sk = Sketch::new();+ let c = sk.add_circle(v(0.0, 0.0), 10.0, Some(0), None).unwrap();+ use ConstraintKind::*;+ sk.add_constraint(Radius { c, value: 10.0 }, None).unwrap();+ let l = sk.add_line(v(-20.0, 12.0), v(20.0, 11.0), None, None, None).unwrap();+ sk.add_constraint(Tangent { a: l, b: c }, None).unwrap();+ sk.add_constraint(Horizontal { l }, None).unwrap();+ assert!(solve(&mut sk).ok());+ let (a, _) = line_pts(&sk, l);+ assert!((a.y.abs() - 10.0).abs() < 1e-7, "{a:?}");+ let m = sk.add_line(v(0.0, 0.0), v(10.0, 3.0), Some(0), None, None).unwrap();+ sk.add_constraint(Angle { a: l, b: m, value: PI / 6.0 }, None).unwrap();+ sk.add_constraint(Length { l: m, value: 8.0 }, None).unwrap();+ assert!(solve(&mut sk).ok());+ let (p, q) = line_pts(&sk, m);+ let (la, lb) = line_pts(&sk, l);+ assert!(((q - p).angle() - (lb - la).angle() - PI / 6.0).abs() < 1e-7, "{la:?} {lb:?} {p:?} {q:?}");+ let n2 = sk.add_line(v(1.0, 1.0), v(2.0, 5.0), None, None, None).unwrap();+ sk.add_constraint(Perpendicular { a: m, b: n2 }, None).unwrap();+ sk.add_constraint(Parallel { a: n2, b: n2 }, None).unwrap();+ assert!(solve(&mut sk).ok());+ let (p2, q2) = line_pts(&sk, n2);+ assert!(((q2 - p2).angle() - (PI / 6.0 + FRAC_PI_2)).abs() < 1e-6 || ((q2 - p2).angle() - (PI / 6.0 - FRAC_PI_2)).abs() < 1e-6);+}++#[test]+fn midpoint_symmetry_point_on_curve_arc() {+ let mut sk = Sketch::new();+ use ConstraintKind::*;+ let l = sk.add_line(v(-5.0, 0.0), v(5.0, 0.0), None, None, None).unwrap();+ let p = sk.add_point(v(1.0, 1.0), None).unwrap();+ sk.add_constraint(Midpoint { p, l }, None).unwrap();+ let a = sk.add_arc(v(0.0, 0.0), v(4.0, 0.0), v(0.0, 4.0), [None, None, None], None).unwrap();+ sk.add_constraint(Radius { c: a, value: 6.0 }, None).unwrap();+ let q = sk.add_point(v(3.0, 3.0), None).unwrap();+ sk.add_constraint(PointOnCurve { p: q, c: a }, None).unwrap();+ let s1 = sk.add_point(v(-2.0, 1.0), None).unwrap();+ let s2 = sk.add_point(v(3.0, -1.5), None).unwrap();+ let axis = sk.add_line(v(0.0, -10.0), v(0.0, 10.0), None, None, None).unwrap();+ sk.add_constraint(Vertical { l: axis }, None).unwrap();+ sk.add_constraint(Symmetric { p: s1, q: s2, l: axis }, None).unwrap();+ let rep = solve(&mut sk);+ assert!(rep.ok(), "{rep:?}");+ let (la, lb) = line_pts(&sk, l);+ assert!(sk.points[p].pos.dist((la + lb) * 0.5) < 1e-7);+ assert!((sk.radius(a).unwrap() - 6.0).abs() < 1e-7);+ let c = sk.center(a).unwrap();+ assert!((sk.points[q].pos.dist(c) - 6.0).abs() < 1e-7);+ let (ax, _) = line_pts(&sk, axis);+ assert!((sk.points[s1].pos.x + sk.points[s2].pos.x - 2.0 * ax.x).abs() < 1e-7);+ assert!((sk.points[s1].pos.y - sk.points[s2].pos.y).abs() < 1e-7);+}++#[test]+fn profiles_rectangle_with_hole_and_split() {+ let mut sk = Sketch::new();+ rect(&mut sk, [v(0.0, 0.0), v(40.0, 0.0), v(40.0, 30.0), v(0.0, 30.0)]);+ sk.add_circle(v(20.0, 15.0), 5.0, None, None).unwrap();+ let ps = find_profiles(&sk);+ assert_eq!(ps.len(), 2, "{ps:?}");+ let big = ps.iter().find(|p| p.region.holes.len() == 1).unwrap();+ assert!((big.area - (1200.0 - PI * 25.0)).abs() < 1e-6);+ let disc = ps.iter().find(|p| p.region.holes.is_empty()).unwrap();+ assert!((disc.area - PI * 25.0).abs() < 1e-6);+ assert_eq!(big.hole_curves.len(), 1);++ // A line across the rectangle splits it into two regions (with the hole in one).+ let mut sk2 = Sketch::new();+ let l = rect(&mut sk2, [v(0.0, 0.0), v(40.0, 0.0), v(40.0, 30.0), v(0.0, 30.0)]);+ let (b0, _) = line_pts(&sk2, l[0]);+ let _ = b0;+ let pa = sk2.add_point(v(10.0, 0.0), None).unwrap();+ let pb = sk2.add_point(v(10.0, 30.0), None).unwrap();+ // Re-split bottom and top edges at x = 10 by rebuilding the sketch as 7 lines.+ let mut s3 = Sketch::new();+ let pts = [v(0.0, 0.0), v(10.0, 0.0), v(40.0, 0.0), v(40.0, 30.0), v(10.0, 30.0), v(0.0, 30.0)];+ let ids: Vec<usize> = pts.iter().map(|p| s3.add_point(*p, None).unwrap()).collect();+ for i in 0..6 {+ s3.add_line_pts(ids[i], ids[(i + 1) % 6], None).unwrap();+ }+ s3.add_line_pts(ids[1], ids[4], None).unwrap();+ let _ = (pa, pb);+ let ps = find_profiles(&s3);+ assert_eq!(ps.len(), 2);+ let mut areas: Vec<f64> = ps.iter().map(|p| p.area).collect();+ areas.sort_by(f64::total_cmp);+ assert!((areas[0] - 300.0).abs() < 1e-9 && (areas[1] - 900.0).abs() < 1e-9, "{areas:?}");+}++#[test]+fn profile_with_arcs_and_construction_ignored() {+ // Slot: two lines and two half arcs.+ let mut sk = Sketch::new();+ let p = [v(0.0, 0.0), v(20.0, 0.0), v(20.0, 10.0), v(0.0, 10.0)];+ let ids: Vec<usize> = p.iter().map(|q| sk.add_point(*q, None).unwrap()).collect();+ sk.add_line_pts(ids[0], ids[1], None).unwrap();+ sk.add_arc(v(20.0, 5.0), p[1], p[2], [None, Some(ids[1]), Some(ids[2])], None).unwrap();+ sk.add_line_pts(ids[2], ids[3], None).unwrap();+ sk.add_arc(v(0.0, 5.0), p[3], p[0], [None, Some(ids[3]), Some(ids[0])], None).unwrap();+ let c = sk.add_line(v(-5.0, -5.0), v(30.0, 20.0), None, None, None).unwrap();+ sk.curves[c].construction = true;+ let ps = find_profiles(&sk);+ assert_eq!(ps.len(), 1, "{ps:?}");+ assert!((ps[0].area - (200.0 + PI * 25.0)).abs() < 1e-6, "{}", ps[0].area);+ assert_eq!(ps[0].outer_curves.len(), 4);+}++#[test]+fn removal_and_references() {+ let mut sk = Sketch::new();+ let l1 = sk.add_line(v(0.0, 0.0), v(1.0, 0.0), None, None, Some("l1")).unwrap();+ let e = sk.resolve_point("l1.end").unwrap();+ let l2 = sk.add_line(v(1.0, 0.0), v(1.0, 1.0), Some(e), None, Some("l2")).unwrap();+ sk.add_constraint(ConstraintKind::Horizontal { l: l1 }, None).unwrap();+ sk.add_constraint(ConstraintKind::Vertical { l: l2 }, None).unwrap();+ assert!(sk.add_line(v(0.0, 0.0), v(1.0, 0.0), None, None, Some("l1")).is_err());+ sk.remove_curves(&[l1]);+ assert_eq!(sk.curves.len(), 1);+ assert_eq!(sk.constraints.len(), 1);+ assert!(sk.resolve_point("l2.start").is_some());+ assert!(sk.resolve_point("l1.start").is_none());+ assert_eq!(sk.points.len(), 3, "origin + l2's two points");+ assert!(solve(&mut sk).ok());+ let json = serde_json::to_string(&sk).unwrap();+ let back: Sketch = serde_json::from_str(&json).unwrap();+ assert_eq!(back, sk);+}++#[test]+fn hostile_values_rejected() {+ let mut sk = Sketch::new();+ assert!(sk.add_point(v(f64::NAN, 0.0), None).is_err());+ assert!(sk.add_circle(v(0.0, 0.0), -1.0, None, None).is_err());+ assert!(sk.add_circle(v(0.0, 0.0), f64::INFINITY, None, None).is_err());+ assert!(sk.add_constraint(ConstraintKind::Horizontal { l: 99 }, None).is_err());+ let c = sk.add_circle(v(0.0, 0.0), 1.0, None, None).unwrap();+ assert!(sk.add_constraint(ConstraintKind::Horizontal { l: c }, None).is_err());+ assert!(sk.add_constraint(ConstraintKind::Radius { c, value: f64::NAN }, None).is_err());+ assert!(sk.add_constraint(ConstraintKind::Radius { c, value: -2.0 }, None).is_err());+}diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.tomlnew file mode 100644index 0000000000..cc50ca194f--- /dev/null+++ b/crates/ui-egui/Cargo.toml@@ -0,0 +1,8 @@+[package]+name = "solvecraft-ui-egui"+version.workspace = true+edition.workspace = true+license.workspace = true++[lints]+workspace = truediff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsnew file mode 100644index 0000000000..8b13789179--- /dev/null+++ b/crates/ui-egui/src/lib.rs@@ -0,0 +1 @@+diff --git a/rustfmt.toml b/rustfmt.tomlnew file mode 100644index 0000000000..3121924d65--- /dev/null+++ b/rustfmt.toml@@ -0,0 +1,2 @@+max_width = 150+use_small_heuristics = "Max"diff --git a/xtask/Cargo.toml b/xtask/Cargo.tomlnew file mode 100644index 0000000000..df7dfa877b--- /dev/null+++ b/xtask/Cargo.toml@@ -0,0 +1,9 @@+[package]+name = "xtask"+version.workspace = true+edition.workspace = true+license.workspace = true+publish = false++[dependencies]+serde_json = { workspace = true }diff --git a/xtask/src/main.rs b/xtask/src/main.rsnew file mode 100644index 0000000000..f328e4d9d0--- /dev/null+++ b/xtask/src/main.rs@@ -0,0 +1 @@+fn main() {}