LTplus-AG
diff --git a/‎rust/geometry/src/profiles/tests.rs‎
Lines changed: 165 additions & 17 deletions b/‎rust/geometry/src/profiles/tests.rs‎
Lines changed: 165 additions & 17 deletions
diff --git a/‎rust/geometry/src/projection_outline.rs‎
Lines changed: 81 additions & 0 deletions b/‎rust/geometry/src/projection_outline.rs‎
Lines changed: 81 additions & 0 deletions
diff --git a/‎rust/geometry/tests/axis2_placement_frame.rs‎
Lines changed: 74 additions & 0 deletions b/‎rust/geometry/tests/axis2_placement_frame.rs‎
Lines changed: 74 additions & 0 deletions
@@ -351,31 +351,179 @@ use super::*;
         assert!(profile.outer.contains(&Point2::new(6.0, 18.0)));
     }
 
+    /// An ASYMMETRIC parent, so the mirror is observable at all.
+    ///
+    /// The previous fixture here mirrored a `2.0 x 4.0` rectangle about its own
+    /// Y-axis: the corner SET maps onto itself, and the assertions were
+    /// `contains()` (order-blind), so `mirror_profile_about_y_axis` could be
+    /// deleted outright and the test still passed. Verified by mutation:
+    /// replacing the outer loop's `p.x = -p.x` with `p.x = p.x` and dropping
+    /// its `reverse()` left the whole `ifc-lite-geometry` lib suite green, and
+    /// `issue_828_sectioned_solid_horizontal` — the only other in-crate
+    /// `IfcMirroredProfileDef` coverage — green too. Stated as a property
+    /// rather than a pass count on purpose: the count was 718 when first
+    /// measured and is 724 today, so a number here goes stale on the next
+    /// commit while "no other test observes the mirror" stays checkable.
+    ///
+    /// This L-shaped outer contour with an off-centre hole pins both halves of
+    /// the reflection: every point's x negates, and each contour's winding
+    /// reverses so an orientation-reversing reflection still hands the earcut
+    /// tessellator a CCW outer loop.
+    const L_WITH_HOLE_IFC: &str = r#"
+#1=IFCCARTESIANPOINT((0.0,0.0));
+#2=IFCCARTESIANPOINT((6.0,0.0));
+#3=IFCCARTESIANPOINT((6.0,2.0));
+#4=IFCCARTESIANPOINT((2.0,2.0));
+#5=IFCCARTESIANPOINT((2.0,5.0));
+#6=IFCCARTESIANPOINT((0.0,5.0));
+#7=IFCPOLYLINE((#1,#2,#3,#4,#5,#6,#1));
+#8=IFCCARTESIANPOINT((3.0,0.5));
+#9=IFCCARTESIANPOINT((5.0,0.5));
+#10=IFCCARTESIANPOINT((5.0,1.5));
+#11=IFCPOLYLINE((#8,#9,#10,#8));
+#12=IFCARBITRARYPROFILEDEFWITHVOIDS(.AREA.,$,#7,(#11));
+#13=IFCMIRROREDPROFILEDEF(.AREA.,$,#12,$,$);
+"#;
+
+    /// Twice the signed area of a closed contour (shoelace). Positive is CCW.
+    fn signed_area2(points: &[Point2<f64>]) -> f64 {
+        let n = points.len();
+        (0..n)
+            .map(|i| {
+                let a = points[i];
+                let b = points[(i + 1) % n];
+                a.x * b.y - b.x * a.y
+            })
+            .sum()
+    }
+
     #[test]
-    fn test_mirrored_profile_uses_derived_operator() {
+    fn test_mirrored_profile_negates_x_and_reverses_winding() {
+        let mut decoder = EntityDecoder::new(L_WITH_HOLE_IFC);
+        let schema = IfcSchema::new();
+        let processor = ProfileProcessor::new(schema);
+
+        let parent = processor
+            .process(
+                &decoder.decode_by_id(12).unwrap(),
+                &mut decoder,
+                TessellationQuality::Medium,
+            )
+            .unwrap();
+        let mirrored = processor
+            .process(
+                &decoder.decode_by_id(13).unwrap(),
+                &mut decoder,
+                TessellationQuality::Medium,
+            )
+            .unwrap();
+
+        // Sanity: the parent really is asymmetric about x, so a dropped
+        // negation cannot hide, and it is authored CCW with a hole.
+        assert!(
+            parent.outer.iter().any(|p| p.x != 0.0),
+            "fixture must be off the mirror axis"
+        );
+        assert!(
+            signed_area2(&parent.outer) > 0.0,
+            "fixture outer contour must be authored CCW"
+        );
+        assert_eq!(parent.holes.len(), 1, "fixture must carry a hole");
+
+        // x -> -x, and the point order reverses.
+        let n = parent.outer.len();
+        assert_eq!(mirrored.outer.len(), n);
+        for i in 0..n {
+            let src = parent.outer[n - 1 - i];
+            let got = mirrored.outer[i];
+            assert!(
+                (got.x + src.x).abs() < 1e-9 && (got.y - src.y).abs() < 1e-9,
+                "outer[{i}]: expected ({}, {}), got ({}, {})",
+                -src.x,
+                src.y,
+                got.x,
+                got.y
+            );
+        }
+
+        // The hole travels with it — same negation, same reversal.
+        assert_eq!(mirrored.holes.len(), 1);
+        let (ph, mh) = (&parent.holes[0], &mirrored.holes[0]);
+        assert_eq!(mh.len(), ph.len());
+        for i in 0..ph.len() {
+            let src = ph[ph.len() - 1 - i];
+            let got = mh[i];
+            assert!(
+                (got.x + src.x).abs() < 1e-9 && (got.y - src.y).abs() < 1e-9,
+                "hole[{i}]: expected ({}, {}), got ({}, {})",
+                -src.x,
+                src.y,
+                got.x,
+                got.y
+            );
+        }
+
+        // The reflection is orientation-reversing; the compensating `reverse()`
+        // must hand the tessellator the SAME chirality it started with, or
+        // downstream earcut emits inside-out triangles.
+        assert!(
+            signed_area2(&mirrored.outer) > 0.0,
+            "mirrored outer must stay CCW, got area2 {}",
+            signed_area2(&mirrored.outer)
+        );
+        assert!(
+            signed_area2(mh).signum() == signed_area2(ph).signum(),
+            "mirrored hole must keep the parent's chirality"
+        );
+    }
+
+    /// `IfcMirroredProfileDef` redeclares `Operator` as derived (`*`) in IFC4,
+    /// so `process_derived_with_depth` short-circuits on the subtype and never
+    /// reads attribute 3. Pin that with an Operator that WOULD move the profile
+    /// if it were applied: the result must be the bare mirror.
+    #[test]
+    fn test_mirrored_profile_ignores_any_supplied_operator() {
         let content = r#"
-#1=IFCDIRECTION((-1.0,0.0));
-#2=IFCDIRECTION((0.0,1.0));
-#3=IFCCARTESIANPOINT((0.0,0.0));
-#4=IFCCARTESIANTRANSFORMATIONOPERATOR2D(#1,#2,#3,1.0);
-#5=IFCRECTANGLEPROFILEDEF(.AREA.,$,$,2.0,4.0);
-#6=IFCMIRROREDPROFILEDEF(.AREA.,$,#5,#4,$);
+#1=IFCCARTESIANPOINT((0.0,0.0));
+#2=IFCCARTESIANPOINT((6.0,0.0));
+#3=IFCCARTESIANPOINT((6.0,2.0));
+#4=IFCCARTESIANPOINT((2.0,2.0));
+#5=IFCCARTESIANPOINT((2.0,5.0));
+#6=IFCCARTESIANPOINT((0.0,5.0));
+#7=IFCPOLYLINE((#1,#2,#3,#4,#5,#6,#1));
+#12=IFCARBITRARYCLOSEDPROFILEDEF(.AREA.,$,#7);
+#14=IFCDIRECTION((0.0,1.0));
+#15=IFCCARTESIANPOINT((100.0,200.0));
+#16=IFCCARTESIANTRANSFORMATIONOPERATOR2D(#14,$,#15,3.0);
+#17=IFCMIRROREDPROFILEDEF(.AREA.,$,#12,#16,$);
 "#;
-
         let mut decoder = EntityDecoder::new(content);
         let schema = IfcSchema::new();
         let processor = ProfileProcessor::new(schema);
-
-        let profile_entity = decoder.decode_by_id(6).unwrap();
-        let profile = processor
-            .process(&profile_entity, &mut decoder, TessellationQuality::Medium)
+        let mirrored = processor
+            .process(
+                &decoder.decode_by_id(17).unwrap(),
+                &mut decoder,
+                TessellationQuality::Medium,
+            )
             .unwrap();
 
-        assert_eq!(profile.outer.len(), 4);
-        assert!(profile.outer.contains(&Point2::new(1.0, -2.0)));
-        assert!(profile.outer.contains(&Point2::new(-1.0, -2.0)));
-        assert!(profile.outer.contains(&Point2::new(-1.0, 2.0)));
-        assert!(profile.outer.contains(&Point2::new(1.0, 2.0)));
+        // Bare mirror of (6,0) is (-6,0). Had the operator (rotate +90 deg,
+        // scale 3, translate (100,200)) been applied on top, no point would
+        // sit anywhere near it.
+        assert!(
+            mirrored
+                .outer
+                .iter()
+                .any(|p| (p.x + 6.0).abs() < 1e-9 && p.y.abs() < 1e-9),
+            "expected the bare mirror; got {:?}",
+            mirrored.outer
+        );
+        assert!(
+            mirrored.outer.iter().all(|p| p.x <= 1e-9 && p.y <= 5.0 + 1e-9),
+            "no point may be displaced by the ignored operator; got {:?}",
+            mirrored.outer
+        );
     }
 
     // ── trim_polyline / SweptDiskSolid trim-param coverage ────────────────────
 
@@ -305,6 +305,87 @@ mod tests {
         assert_eq!(out.contours.len(), 2, "two disjoint footprints expected");
     }
 
+    /// The other five tests in this module all pass `ProjectionAxis::Y`, and
+    /// the only other in-crate caller (`contour_bool2d_tests`) passes `Z`. So
+    /// the `X` arm of `project`/`axis_coord` — the plan/section axis used for
+    /// elevations looking along world X — had no test at all: swapping it to
+    /// `(p[1], p[2])` left the whole `ifc-lite-geometry` lib suite green.
+    /// `ProjectionAxis::from_u8`, the WASM-boundary decode
+    /// (`wasm-bindings/src/api/mesh_outline.rs`), was likewise untested, so
+    /// exchanging its `0` and `2` arms was invisible too.
+    ///
+    /// One box with three DISTINCT extents pins all three axes against each
+    /// other: any axis permutation moves at least one of the ranges below.
+    #[test]
+    fn each_projection_axis_picks_its_own_two_drawing_coordinates() {
+        // x ∈ [1,4], y ∈ [0,2], z ∈ [-1,2]. Three properties, and the third is
+        // the one a symmetric range silently destroys: no two extents are
+        // equal; no extent equals ANOTHER's negation; and no extent equals ITS
+        // OWN negation. z was [-1,1], which satisfies the first two and fails
+        // the third, so the mirror assertion below held at 0 == 0 with
+        // flipping deleted entirely.
+        let (pos, idx) = box_mesh(1.0, 4.0, 0.0, 2.0, -1.0, 2.0, false);
+
+        // axis = X → (u = z, v = y); the cut axis is x.
+        let x = mesh_outline_2d(&pos, &idx, ProjectionAxis::X, false).expect("x outline");
+        let (minu, minv, maxu, maxv) = bbox_2d(&x.contours);
+        assert!(
+            (minu + 1.0).abs() < 1e-4 && (maxu - 2.0).abs() < 1e-4,
+            "axis=X u must be the z extent, got {minu}..{maxu}"
+        );
+        assert!(
+            (minv - 0.0).abs() < 1e-4 && (maxv - 2.0).abs() < 1e-4,
+            "axis=X v must be the y extent, got {minv}..{maxv}"
+        );
+        assert!(
+            (x.axis_min - 1.0).abs() < 1e-4 && (x.axis_max - 4.0).abs() < 1e-4,
+            "axis=X band must be the x extent, got {}..{}",
+            x.axis_min,
+            x.axis_max
+        );
+
+        // axis = Z → (u = x, v = y); the cut axis is z.
+        let z = mesh_outline_2d(&pos, &idx, ProjectionAxis::Z, false).expect("z outline");
+        let (minu, minv, maxu, maxv) = bbox_2d(&z.contours);
+        assert!(
+            (minu - 1.0).abs() < 1e-4 && (maxu - 4.0).abs() < 1e-4,
+            "axis=Z u must be the x extent, got {minu}..{maxu}"
+        );
+        assert!(
+            (minv - 0.0).abs() < 1e-4 && (maxv - 2.0).abs() < 1e-4,
+            "axis=Z v must be the y extent, got {minv}..{maxv}"
+        );
+        assert!(
+            (z.axis_min + 1.0).abs() < 1e-4 && (z.axis_max - 2.0).abs() < 1e-4,
+            "axis=Z band must be the z extent, got {}..{}",
+            z.axis_min,
+            z.axis_max
+        );
+
+        // Flipping mirrors U and leaves V alone — `flipped_axis_mirrors_u`
+        // above never checks that V survives.
+        let xf = mesh_outline_2d(&pos, &idx, ProjectionAxis::X, true).expect("x flipped");
+        let (fminu, fminv, fmaxu, fmaxv) = bbox_2d(&xf.contours);
+        let (uminu, _, umaxu, _) = bbox_2d(&x.contours);
+        assert!(
+            (fminu + umaxu).abs() < 1e-4 && (fmaxu + uminu).abs() < 1e-4,
+            "flip must mirror u: {fminu}..{fmaxu} vs {uminu}..{umaxu}"
+        );
+        assert!(
+            (fminv - 0.0).abs() < 1e-4 && (fmaxv - 2.0).abs() < 1e-4,
+            "flip must leave v alone, got {fminv}..{fmaxv}"
+        );
+    }
+
+    /// The 0/1/2 = x/y/z decode crossing the WASM boundary.
+    #[test]
+    fn from_u8_decodes_the_wasm_axis_convention() {
+        assert_eq!(ProjectionAxis::from_u8(0), Some(ProjectionAxis::X));
+        assert_eq!(ProjectionAxis::from_u8(1), Some(ProjectionAxis::Y));
+        assert_eq!(ProjectionAxis::from_u8(2), Some(ProjectionAxis::Z));
+        assert_eq!(ProjectionAxis::from_u8(3), None);
+    }
+
     #[test]
     fn empty_or_degenerate_returns_none() {
         assert!(mesh_outline_2d(&[], &[], ProjectionAxis::Y, false).is_none());
 
@@ -0,0 +1,74 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+//! `IfcAxis2Placement3D` with BOTH a non-identity rotation and a non-zero
+//! Location — the one combination `transform.rs`'s own unit tests never make.
+//!
+//! `parse_axis2_placement_3d_defaults_missing_axis_and_ref_direction` is at
+//! `(10, 20, 30)` with the identity rotation, and the three orthogonalization
+//! tests (`..._defaults_ref_direction_when_only_axis_given`,
+//! `..._orthogonalizes_parallel_ref_direction_low_z` / `..._high_z`) all place
+//! the origin at `(0, 0, 0)`. Under either, the classic
+//! "the translation column got rotated too" mutation —
+//! `transform[(_, 3)] = R * location` instead of `location` — is the identity:
+//! `R·t == t` when `R` is the identity, and `R·0 == 0` for any `R`.
+//!
+//! Verified by mutation: rotating the translation column in
+//! `build_axis2_matrix` leaves all four of those unit tests green, while the
+//! test below fails.
+//!
+//! The crate is NOT blind to that mutation. At FULL crate scope six existing
+//! tests also fail:
+//!
+//!   processors::tests::test_polygonal_bounded_half_space_respects_boundary
+//!   tests/voids_inline_matrix_test.rs        inline_void_matrix
+//!   tests/rect_param_gate.rs                 param_fast_path_fires_watertight...
+//!   tests/issue_1167_rotated_wall_opening.rs rotated_wall_opening_is_not_overcut
+//!   tests/issue_1167_rotated_wall_opening.rs rotated_opening_cuts_clean_at_every_angle
+//!   tests/issue_1167_real_wall.rs            rotated_wall_openings_not_overcut_or_fragmented
+//!
+//! An earlier version of this header said "the one test that does catch it".
+//! That was measured with `cargo test --lib`, which excludes `tests/` -- the
+//! directory this file is in. Five of the six were invisible to the scope the
+//! claim was made at.
+//!
+//! Every one of them is downstream of a boolean or a cut volume, so each fails
+//! with something like "the clipped strip should be removed" and points at a
+//! CSG result rather than at a placement. This is the only test that reads the
+//! translation column directly, which is the reason to keep it -- not scarcity.
+//!
+//! This lives in `tests/` rather than beside them because the test body would
+//! push `transform.rs` (513 lines) past its 525-line ratchet budget.
+
+use ifc_lite_core::EntityDecoder;
+use ifc_lite_geometry::parse_axis2_placement_3d;
+
+#[test]
+fn a_rotated_placement_does_not_rotate_its_own_location() {
+    // Axis = (0,0,1) with RefDirection = (0,1,0) is a +90 degree turn about Z,
+    // so local X maps to world +Y and local Y to world -X. Under `R * location`
+    // the translation column would read (-20, 10, 30) instead of (10, 20, 30).
+    let content = "\
+#1=IFCCARTESIANPOINT((10.0,20.0,30.0));
+#2=IFCDIRECTION((0.0,0.0,1.0));
+#3=IFCDIRECTION((0.0,1.0,0.0));
+#4=IFCAXIS2PLACEMENT3D(#1,#2,#3);";
+    let mut decoder = EntityDecoder::new(content);
+    let placement = decoder.decode_by_id(4).unwrap();
+
+    let m = parse_axis2_placement_3d(&placement, &mut decoder).unwrap();
+
+    // Sanity: the rotation really is non-trivial (local X -> world +Y) ...
+    assert!((m[(0, 0)] - 0.0).abs() < 1e-9, "m00 {}", m[(0, 0)]);
+    assert!((m[(1, 0)] - 1.0).abs() < 1e-9, "m10 {}", m[(1, 0)]);
+    // ... and Y = Z x X = (0,0,1) x (0,1,0) = (-1,0,0).
+    assert!((m[(0, 1)] + 1.0).abs() < 1e-9, "m01 {}", m[(0, 1)]);
+    assert!((m[(1, 1)] - 0.0).abs() < 1e-9, "m11 {}", m[(1, 1)]);
+
+    // A placement is [R | t], not [R | R·t]: Location is already expressed in
+    // the parent frame, so the rotation must not touch it.
+    assert!((m[(0, 3)] - 10.0).abs() < 1e-9, "tx {}", m[(0, 3)]);
+    assert!((m[(1, 3)] - 20.0).abs() < 1e-9, "ty {}", m[(1, 3)]);
+    assert!((m[(2, 3)] - 30.0).abs() < 1e-9, "tz {}", m[(2, 3)]);
+}