Honor selfCollisionEnabled on imported cables

The USD cable importer built rod articulations via add_rod / add_rod_graph
but never resolved the per-articulation self-collision flag, so authoring
newton:selfCollisionEnabled on a cable had no effect while the general
rigid importer honored it. This left non-adjacent segments of the same
cable colliding even when self-collision was disabled.

Resolve self_collision_enabled per cable articulation (newton namespace,
with the physxArticulation fallback) and, when disabled, filter collisions
between all of the cable's segment shape pairs, mirroring the rigid
importer. Welded rod graphs disable self-collision when any member curve
opts out, and warn on mixed authoring.

Author: mmichelis

CHANGELOG.md

@@ -91,6 +91,7 @@
 - Fix masked `SolverCoupledProxy.reset()` calls clearing proxy feedback history for unselected worlds.
 - Fix hydroelastic primitive texture SDF generation to sample analytic primitive distances instead of temporary tessellated meshes. (#3239)
 - Fix MJCF, URDF, and USD imports rendering collision-only bodies as visuals when the asset authors visual geometry elsewhere. (#3291)
+- Fix `ModelBuilder.add_usd()` ignoring `newton:selfCollisionEnabled` on imported cables; a cable articulation with self-collision disabled now filters collisions between its non-adjacent segments.
 - Fix `SchemaResolverPhysx` reading every D6 translational limit gain from the `linear` instance instead of its `transX`, `transY`, or `transZ` instance.
 - Fix USD capsule, cylinder, and cone visuals and sites without authored `radius`/`height` to use the UsdGeom schema fallbacks, matching collision shapes.
 - Fix `ViewerUSD` texture consumers observing partially written PNGs by publishing generated textures atomically (#3288)

newton/_src/utils/import_usd.py

@@ -4216,6 +4216,7 @@ def initialize_free_joint_velocities() -> None:
             linear_unit=linear_unit,
             ignore_paths=ignore_paths,
             verbose=verbose,
+            enable_self_collisions=enable_self_collisions,
             path_body_map=path_body_map,
             path_shape_map=path_shape_map,
             path_cable_map=path_cable_map,

newton/_src/utils/import_usd_deformable_cable.py

@@ -12,12 +12,14 @@
 
 from __future__ import annotations
 
+import itertools
 import math
 import warnings
 from dataclasses import replace
 
 import warp as wp
 
+from ..usd.schema_resolver import PrimType
 from .import_usd_deformable_utils import (
     _DEFAULT_CABLE_RADIUS,
     _apply_cable_masses,
@@ -41,6 +43,20 @@
 )
 
 
+def _apply_cable_self_collision_filter(builder, bodies, self_collision_enabled: bool) -> None:
+    """Filter all shape pairs among a cable articulation's bodies when self-collision is disabled.
+
+    Adjacent segments are already filtered by the CABLE joints (``collision_filter_parent``);
+    this extends filtering to the non-adjacent pairs, mirroring the general rigid importer.
+    """
+    if self_collision_enabled or len(bodies) < 2:
+        return
+    for b1, b2 in itertools.combinations(bodies, 2):
+        for s1 in builder.body_shapes[b1]:
+            for s2 in builder.body_shapes[b2]:
+                builder.add_shape_collision_filter_pair(s1, s2)
+
+
 def _read_validated_curve_topology(curves, path: str, *, warn: bool = True):
     """Read a cable prim's ``points`` / ``curveVertexCounts`` after validating the partition.
 
@@ -418,6 +434,29 @@ def global_node(local: tuple[str, int]) -> int:
             body_frame_origin="com",
         )
 
+        # One rod graph is one articulation, so resolve self-collision per component: a welded graph
+        # disables it if ANY member curve prim authors newton:selfCollisionEnabled=False.
+        self_collision_states = {
+            key: bool(
+                ctx.resolver.get_value(
+                    curve_recs[key].prim,
+                    prim_type=PrimType.ARTICULATION,
+                    key="self_collision_enabled",
+                    default=ctx.enable_self_collisions,
+                    verbose=verbose,
+                )
+            )
+            for key in comp_paths
+        }
+        graph_self_collision = all(self_collision_states.values())
+        if not graph_self_collision and any(self_collision_states.values()):
+            warnings.warn(
+                f"cable graph '{cid}': welded cables mix self-collision-enabled and "
+                f"self-collision-disabled curves; the whole graph disables self-collision.",
+                stacklevel=2,
+            )
+        _apply_cable_self_collision_filter(builder, body_ids, graph_self_collision)
+
         # Partition graph bodies back to their owning curve, and rebuild the per-prim anchor
         # maps the curve-to-xform attachment pass reads (point index / segment index -> body).
         per_prim_segments: dict[str, dict[int, tuple[int, float]]] = {}
@@ -627,6 +666,17 @@ def _deformable_import_cable(ctx: _DeformableImportContext, consumed_cable_curve
             has_shape_collision=collision_enabled,
             has_particle_collision=collision_enabled,
         )
+        # Each curve in this prim becomes its own articulation via add_rod below, so resolve the
+        # prim's self-collision flag once and apply the filter per curve (not across sibling curves).
+        self_collision_enabled = bool(
+            ctx.resolver.get_value(
+                prim,
+                prim_type=PrimType.ARTICULATION,
+                key="self_collision_enabled",
+                default=ctx.enable_self_collisions,
+                verbose=ctx.verbose,
+            )
+        )
 
         cable_bodies: list[int] = []
         cable_joints: list[int] = []
@@ -719,6 +769,8 @@ def _deformable_import_cable(ctx: _DeformableImportContext, consumed_cable_curve
                 wrap_in_articulation=True,
                 body_frame_origin="com",
             )
+            # This curve is its own articulation, so filter its own segments' self-collisions here.
+            _apply_cable_self_collision_filter(builder, bodies, self_collision_enabled)
             cable_bodies.extend(bodies)
             cable_joints.extend(joints)
             cable_point_runs.append((start, n, bodies))

newton/_src/utils/import_usd_deformable_utils.py

@@ -1022,5 +1022,7 @@ class _DeformableImportContext:
     path_soft_attrs: dict
     path_attachment_map: dict
     path_attachment_attrs: dict
+    # Default for self-collision when an articulation authors no newton:selfCollisionEnabled.
+    enable_self_collisions: bool = True
     # Filled by _scout_deformable_prims so the passes iterate buckets instead of the stage.
     prims: _DeformablePrimBuckets = field(default_factory=_DeformablePrimBuckets)

newton/tests/test_import_usd_deformable_cable.py

@@ -943,6 +943,128 @@ def test_cable_collision_gating(self):
                     self.assertEqual(is_colliding, expected_colliding, f"shape {i}")
                 builder.finalize()
 
+    def test_cable_self_collision_disabled_filters_non_adjacent_pairs(self):
+        """newton:selfCollisionEnabled=False filters non-adjacent cable segment shape pairs.
+
+        Adjacent segments are already filtered by the CABLE joints; the flag extends the
+        filtering to non-adjacent pairs, mirroring the general rigid importer. The default
+        (flag True or unauthored) leaves those pairs unfiltered.
+        """
+        from pxr import Sdf
+
+        # 5 points -> 4 segment bodies, so there are non-adjacent pairs to check.
+        pts = [(0.0, 0.0, 1.0), (0.1, 0.0, 1.0), (0.2, 0.0, 1.0), (0.3, 0.0, 1.0), (0.4, 0.0, 1.0)]
+        for case, self_collision in (("disabled", False), ("enabled", True), ("unauthored", None)):
+            with self.subTest(case=case):
+                stage = _deformable_stage()
+                curve = _add_cable_curve(stage, "/World/Cable", pts)
+                if self_collision is not None:
+                    curve.GetPrim().CreateAttribute("newton:selfCollisionEnabled", Sdf.ValueTypeNames.Bool).Set(
+                        self_collision
+                    )
+                builder = newton.ModelBuilder()
+                builder.add_usd(stage)
+                b0, b1 = group_range(builder, "cable", "/World/Cable", "body")
+                self.assertEqual(b1 - b0, 4)
+                # A non-adjacent segment pair (bodies b0 and b0+2).
+                s1 = builder.body_shapes[b0][0]
+                s2 = builder.body_shapes[b0 + 2][0]
+                pair = (min(s1, s2), max(s1, s2))
+                pairs = set(builder.shape_collision_filter_pairs)
+                if case == "disabled":
+                    self.assertIn(pair, pairs)
+                else:
+                    self.assertNotIn(pair, pairs)
+
+    def test_welded_graph_self_collision_disabled_filters_non_adjacent_pairs(self):
+        """A welded cable graph honors newton:selfCollisionEnabled=False on any member curve.
+
+        Disabling self-collision on one welded member filters non-adjacent segment shape pairs
+        across the whole graph articulation (both within a curve and between welded curves), and
+        the importer warns that the mixed authoring resolves to self-collision disabled.
+        """
+        from pxr import Sdf
+
+        for case, author in (("disabled", True), ("default", False)):
+            with self.subTest(case=case):
+                # Hard, coincident junction welds CableA and CableB into one graph articulation.
+                stage = self._author_attached_cable_pair(gap=0.0)
+                if author:
+                    stage.GetPrimAtPath("/World/CableA").CreateAttribute(
+                        "newton:selfCollisionEnabled", Sdf.ValueTypeNames.Bool
+                    ).Set(False)
+                builder = newton.ModelBuilder()
+                if author:
+                    # Members disagree (CableB unauthored -> default True), so the importer warns.
+                    with self.assertWarnsRegex(UserWarning, "disables self-collision"):
+                        builder.add_usd(stage)
+                else:
+                    builder.add_usd(stage)
+                self.assertEqual(builder.articulation_count, 1)
+                a0, _ = group_range(builder, "cable", "/World/CableA", "body")
+                b0, _ = group_range(builder, "cable", "/World/CableB", "body")
+                pairs = set(builder.shape_collision_filter_pairs)
+                # A within-curve non-adjacent pair and a cross-curve non-adjacent pair.
+                within = self._shape_pair(builder, a0, a0 + 2)
+                cross = self._shape_pair(builder, a0 + 2, b0 + 2)
+                if case == "disabled":
+                    self.assertIn(within, pairs)
+                    self.assertIn(cross, pairs)
+                else:
+                    self.assertNotIn(within, pairs)
+                    self.assertNotIn(cross, pairs)
+
+    def test_self_collision_disabled_does_not_filter_across_curves_in_one_prim(self):
+        """A multi-curve BasisCurves prim filters each curve's own segments, not across curves.
+
+        Every curveVertexCounts entry becomes its own articulation via add_rod, so disabling
+        self-collision must filter within a curve while leaving independent sibling curves in
+        the same prim free to collide.
+        """
+        from pxr import Sdf, UsdGeom
+
+        stage = _deformable_stage()
+        curves = UsdGeom.BasisCurves.Define(stage, "/World/Cable")
+        curves.CreateTypeAttr().Set(UsdGeom.Tokens.linear)
+        # Two independent 4-point curves (3 segment bodies each) in one prim.
+        curves.CreatePointsAttr(
+            [
+                (0.0, 0.0, 1.0),
+                (0.1, 0.0, 1.0),
+                (0.2, 0.0, 1.0),
+                (0.3, 0.0, 1.0),
+                (0.0, 1.0, 1.0),
+                (0.1, 1.0, 1.0),
+                (0.2, 1.0, 1.0),
+                (0.3, 1.0, 1.0),
+            ]
+        )
+        curves.CreateCurveVertexCountsAttr([4, 4])
+        curves.GetPrim().AddAppliedSchema("PhysicsCurvesDeformableSimAPI")
+        curves.GetPrim().AddAppliedSchema("PhysicsCollisionAPI")
+        _bind_deformable_material(stage, curves.GetPrim(), "/World/CableMat", thickness=0.02)
+        curves.GetPrim().CreateAttribute("newton:selfCollisionEnabled", Sdf.ValueTypeNames.Bool).Set(False)
+
+        builder = newton.ModelBuilder()
+        builder.add_usd(stage)
+
+        # Two curves -> two separate articulations.
+        self.assertEqual(builder.articulation_count, 2)
+        b0, b1 = group_range(builder, "cable", "/World/Cable", "body")
+        self.assertEqual(b1 - b0, 6)
+        pairs = set(builder.shape_collision_filter_pairs)
+        # Within the first curve, the non-adjacent pair is filtered.
+        self.assertIn(self._shape_pair(builder, b0, b0 + 2), pairs)
+        # Across the two curves (separate articulations), nothing is filtered.
+        self.assertNotIn(self._shape_pair(builder, b0, b0 + 3), pairs)
+
+    @staticmethod
+    def _shape_pair(builder, body_a, body_b):
+        """Canonical (min, max) shape-filter pair for the first shapes of two bodies."""
+        s1 = builder.body_shapes[body_a][0]
+        s2 = builder.body_shapes[body_b][0]
+        return (min(s1, s2), max(s1, s2))
+
     def test_neg_inf_junction_stiffness_does_not_weld(self):
         """-inf is the material sentinel, not the attachment one (+inf = hard): a
         junction authoring -inf stiffness is nonconforming and must not weld the