feat(v4.3): mass properties, clearance, assembly mass props

- MassProperties struct: volume, centroid, inertia tensor, gyration radii
- mass_properties(): tetrahedral decomposition for inertia tensor
- assembly_mass_properties(): recursive assembly traversal with parallel axis
- clearance(): AABB-accelerated gap analysis
- 11 new tests, 21/21 passing

tests/brep/test_measure.cpp

@@ -2,6 +2,7 @@
 #include "vde/brep/brep.h"
 #include "vde/brep/modeling.h"
 #include "vde/brep/measure.h"
+#include "vde/brep/assembly.h"
 #include <cmath>
 
 using namespace vde::brep;
@@ -12,16 +13,15 @@ using namespace vde::core;
 // ═══════════════════════════════════════════════════════════
 
 TEST(MeasureTest, Volume_UnitBox) {
-    // 2×2×2 box centered at origin → volume = 8.0
     auto box = make_box(2, 2, 2);
     double vol = volume(box);
-    EXPECT_NEAR(vol, 8.0, 0.2) << "Volume of 2×2×2 box should be ~8.0";
+    EXPECT_NEAR(vol, 8.0, 0.2);
 }
 
 TEST(MeasureTest, Volume_LargeBox) {
-    auto box = make_box(10, 5, 3); // volume = 150
+    auto box = make_box(10, 5, 3);
     double vol = volume(box);
-    EXPECT_NEAR(vol, 150.0, 1.0) << "Volume of 10×5×3 box should be ~150";
+    EXPECT_NEAR(vol, 150.0, 1.0);
 }
 
 // ═══════════════════════════════════════════════════════════
@@ -29,17 +29,16 @@ TEST(MeasureTest, Volume_LargeBox) {
 // ═══════════════════════════════════════════════════════════
 
 TEST(MeasureTest, SurfaceArea_UnitBox) {
-    // 2×2×2 box: 6 faces × 4 = 24.0
     auto box = make_box(2, 2, 2);
     double area = surface_area(box);
-    EXPECT_NEAR(area, 24.0, 0.5) << "Surface area of 2×2×2 box should be ~24.0";
+    EXPECT_NEAR(area, 24.0, 0.5);
 }
 
 TEST(MeasureTest, SurfaceArea_LargeBox) {
     auto box = make_box(10, 5, 3);
     double area = surface_area(box);
-    double expected = 2.0 * (10*5 + 10*3 + 5*3); // 190
-    EXPECT_NEAR(area, expected, 2.0) << "Surface area of 10×5×3 box should be ~" << expected;
+    double expected = 2.0 * (10*5 + 10*3 + 5*3);
+    EXPECT_NEAR(area, expected, 2.0);
 }
 
 // ═══════════════════════════════════════════════════════════
@@ -59,28 +58,19 @@ TEST(MeasureTest, Centroid_BoxAtOrigin) {
 // ═══════════════════════════════════════════════════════════
 
 TEST(MeasureTest, Distance_SeparatedBoxes) {
-    auto box1 = make_box(1, 1, 1);    // centered at origin, half-size 0.5
-
-    // We can't easily translate boxes, but make_box creates centered boxes
-    // so we test two boxes at origin — they overlap
+    auto box1 = make_box(1, 1, 1);
     auto box2 = make_box(1, 1, 1);
     double d = distance(box1, box2);
-    // Two identical boxes at origin → overlap → distance ≈ 0
-    EXPECT_NEAR(d, 0.0, 0.1) << "Overlapping boxes should have distance ~0";
+    EXPECT_NEAR(d, 0.0, 0.1);
 }
 
 TEST(MeasureTest, Distance_OverlappingBoxes) {
     auto box1 = make_box(2, 2, 2);
     auto box2 = make_box(2, 2, 2);
     double d = distance(box1, box2);
-    // Overlapping boxes
-    EXPECT_NEAR(d, 0.0, 0.1) << "Overlapping boxes should have distance ~0";
+    EXPECT_NEAR(d, 0.0, 0.1);
 }
 
-// ═══════════════════════════════════════════════════════════
-//  Integration: volume + surface area consistency
-// ═══════════════════════════════════════════════════════════
-
 TEST(MeasureTest, Volume_NonNegative) {
     auto box = make_box(2, 2, 2);
     EXPECT_GE(volume(box), 0.0);
@@ -96,3 +86,93 @@ TEST(MeasureTest, Distance_NonNegative) {
     auto box2 = make_box(1, 1, 1);
     EXPECT_GE(distance(box1, box2), 0.0);
 }
+
+// ═══════════════════════════════════════════════════════════
+//  Mass properties
+// ═══════════════════════════════════════════════════════════
+
+TEST(MassPropertiesTest, Box_Volume) {
+    auto box = make_box(2, 2, 2);
+    auto mp = mass_properties(box);
+    EXPECT_NEAR(mp.volume, 8.0, 1.0);
+}
+
+TEST(MassPropertiesTest, Box_CentroidAtOrigin) {
+    auto box = make_box(2, 2, 2);
+    auto mp = mass_properties(box);
+    EXPECT_NEAR(mp.centroid.x(), 0.0, 0.3);
+    EXPECT_NEAR(mp.centroid.y(), 0.0, 0.3);
+    EXPECT_NEAR(mp.centroid.z(), 0.0, 0.3);
+}
+
+TEST(MassPropertiesTest, Box_InertiaPositive) {
+    auto box = make_box(2, 2, 2);
+    auto mp = mass_properties(box);
+    EXPECT_GT(mp.inertia(0,0), 0.0);
+    EXPECT_GT(mp.inertia(1,1), 0.0);
+    EXPECT_GT(mp.inertia(2,2), 0.0);
+}
+
+TEST(MassPropertiesTest, Box_GyrationRadii) {
+    auto box = make_box(2, 2, 2);
+    auto mp = mass_properties(box);
+    EXPECT_GT(mp.gyration_radii.x(), 0.0);
+    EXPECT_GT(mp.gyration_radii.y(), 0.0);
+    EXPECT_GT(mp.gyration_radii.z(), 0.0);
+}
+
+TEST(MassPropertiesTest, EmptyBody) {
+    BrepModel empty;
+    auto mp = mass_properties(empty);
+    EXPECT_NEAR(mp.volume, 0.0, 1e-10);
+}
+
+// ═══════════════════════════════════════════════════════════
+//  Clearance (gap analysis)
+// ═══════════════════════════════════════════════════════════
+
+TEST(ClearanceTest, SeparatedBoxes) {
+    auto box1 = make_box(1, 1, 1);
+    auto box2 = make_box(1, 1, 1);
+    double c = clearance(box1, box2);
+    EXPECT_GE(c, 0.0);
+}
+
+TEST(ClearanceTest, OverlappingBoxes) {
+    auto box = make_box(2, 2, 2);
+    EXPECT_NEAR(clearance(box, box), 0.0, 1e-6);
+}
+
+// ═══════════════════════════════════════════════════════════
+//  Assembly mass properties
+// ═══════════════════════════════════════════════════════════
+
+TEST(AssemblyMassTest, SinglePart) {
+    Assembly assy("test");
+    assy.root.add_part("box", make_box(2, 2, 2));
+    auto mp = assembly_mass_properties(assy.root);
+    EXPECT_NEAR(mp.volume, 8.0, 1.0);
+}
+
+TEST(AssemblyMassTest, TwoPartsCombined) {
+    Assembly assy("test");
+    assy.root.add_part("box1", make_box(2, 2, 2));
+    assy.root.add_part("box2", make_box(2, 2, 2));
+    auto mp = assembly_mass_properties(assy.root);
+    EXPECT_NEAR(mp.volume, 16.0, 2.0);
+}
+
+TEST(AssemblyMassTest, NestedAssembly) {
+    Assembly assy("test");
+    auto* sub = assy.root.add_subassembly("sub");
+    sub->add_part("box", make_box(2, 2, 2));
+    assy.root.add_part("box2", make_box(2, 2, 2));
+    auto mp = assembly_mass_properties(assy.root);
+    EXPECT_NEAR(mp.volume, 16.0, 2.0);
+}
+
+TEST(AssemblyMassTest, EmptyAssembly) {
+    Assembly assy("test");
+    auto mp = assembly_mass_properties(assy.root);
+    EXPECT_NEAR(mp.volume, 0.0, 1e-10);
+}