Deduplicate roundoff-equivalent contacts

Select one canonical winner when separate reduction slots contain contact geometry that differs only by floating-point rounding. Keep the comparison bounded to the seven winners in each entry.

Author: nvtw

newton/_src/geometry/contact_reduction_global.py

@@ -120,6 +120,40 @@ def is_contact_already_exported(
     return False
 
 
+@wp.func
+def _floats_are_near_ulps(a: float, b: float) -> bool:
+    """Return whether two floats are close in ULPs and absolute magnitude."""
+    if wp.abs(a - b) > 1.0e-8:
+        return False
+    a_bits = float_flip(a)
+    b_bits = float_flip(b)
+    if a_bits > b_bits:
+        return a_bits - b_bits <= wp.uint32(16)
+    return b_bits - a_bits <= wp.uint32(16)
+
+
+@wp.func
+def _contacts_are_numerically_equivalent(
+    contact_a: int,
+    contact_b: int,
+    position_depth: wp.array[wp.vec4],
+    normal: wp.array[wp.vec2],
+) -> bool:
+    """Return whether two buffered contacts differ only by float rounding."""
+    pd_a = position_depth[contact_a]
+    pd_b = position_depth[contact_b]
+    n_a = normal[contact_a]
+    n_b = normal[contact_b]
+    return (
+        _floats_are_near_ulps(pd_a[0], pd_b[0])
+        and _floats_are_near_ulps(pd_a[1], pd_b[1])
+        and _floats_are_near_ulps(pd_a[2], pd_b[2])
+        and _floats_are_near_ulps(pd_a[3], pd_b[3])
+        and _floats_are_near_ulps(n_a[0], n_b[0])
+        and _floats_are_near_ulps(n_a[1], n_b[1])
+    )
+
+
 @wp.func
 def compute_effective_radius(shape_type: int, shape_scale: wp.vec4) -> float:
     """Compute effective radius for a shape based on its type.
@@ -1619,7 +1653,7 @@ def export_reduced_contacts_kernel(
             exported_ids = exported_ids_vec()
             num_exported = int(0)
 
-            # Read all value slots for this entry (slot-major layout)
+            # Read all value slots for this entry (slot-major layout).
             for slot in range(wp.static(VALUES_PER_KEY)):
                 value = ht_values[slot * ht_capacity + entry_idx]
 
@@ -1638,6 +1672,28 @@ def export_reduced_contacts_kernel(
                 exported_ids[num_exported] = contact_id
                 num_exported = num_exported + 1
 
+            # Suppress roundoff-equivalent winners using the lower topology
+            # fingerprint. This examines at most 21 pairs per seven-slot entry.
+            duplicate_mask = int(0)
+            for local_idx in range(num_exported):
+                contact_id = exported_ids[local_idx]
+                fingerprint = contact_fingerprints[contact_id]
+                for other_idx in range(local_idx):
+                    other_id = exported_ids[other_idx]
+                    if _contacts_are_numerically_equivalent(contact_id, other_id, position_depth, normal):
+                        other_fingerprint = contact_fingerprints[other_id]
+                        if fingerprint < other_fingerprint:
+                            duplicate_mask = duplicate_mask | (1 << other_idx)
+                        else:
+                            duplicate_mask = duplicate_mask | (1 << local_idx)
+
+            for local_idx in range(num_exported):
+                if duplicate_mask & (1 << local_idx) != 0:
+                    continue
+
+                contact_id = exported_ids[local_idx]
+                fingerprint = contact_fingerprints[contact_id]
+
                 # Cross-entry dedup: same contact can win slots in different entries
                 # (e.g., normal-bin AND voxel entry). Atomic flag per contact_id.
                 old_flag = wp.atomic_add(exported_flags, contact_id, 1)
@@ -1677,7 +1733,7 @@ def export_reduced_contacts_kernel(
                 contact_data.shape_a = shape_a
                 contact_data.shape_b = shape_b
                 contact_data.gap_sum = gap_sum
-                contact_data.sort_sub_key = contact_fingerprints[contact_id]
+                contact_data.sort_sub_key = fingerprint
 
                 # Call the writer function
                 writer_func(contact_data, writer_data, -1)

newton/tests/test_contact_reduction_global.py

@@ -15,6 +15,7 @@
     GlobalContactReducer,
     GlobalContactReducerData,
     _make_contact_value_det,
+    _make_contact_value_fast,
     _make_preprune_probe_det,
     _unpack_contact_id_det,
     create_export_reduced_contacts_kernel,
@@ -23,8 +24,10 @@
     export_and_reduce_contact,
     export_and_reduce_contact_centered,
     export_and_reduce_contact_centered_two_spatial_depths,
+    export_contact_to_buffer,
     make_contact_key,
 )
+from newton._src.geometry.hashtable import hashtable_find_or_insert
 from newton._src.geometry.narrow_phase import ContactWriterData
 from newton.tests.unittest_utils import add_function_test, get_test_devices
 
@@ -539,6 +542,34 @@ def store_contacts_kernel(
         device=device,
     )
 
+    @wp.kernel
+    def store_roundoff_duplicate_winners_kernel(reducer_data: GlobalContactReducerData):
+        contact_a = export_contact_to_buffer(
+            shape_a=10,
+            shape_b=110,
+            position=wp.vec3(0.01, 0.02, 0.03),
+            normal=wp.vec3(0.0, 1.0, 0.0),
+            depth=-0.01,
+            fingerprint=10,
+            reducer_data=reducer_data,
+        )
+        contact_b = export_contact_to_buffer(
+            shape_a=10,
+            shape_b=110,
+            position=wp.vec3(0.010000000707805157, 0.02, 0.03),
+            normal=wp.vec3(0.0, 1.0, 0.0),
+            depth=-0.01,
+            fingerprint=20,
+            reducer_data=reducer_data,
+        )
+        entry_idx = hashtable_find_or_insert(
+            make_contact_key(10, 110, 0), reducer_data.ht_keys, reducer_data.ht_active_slots
+        )
+        reducer_data.ht_values[entry_idx] = _make_contact_value_fast(1.0, 10, contact_a)
+        reducer_data.ht_values[reducer_data.ht_capacity + entry_idx] = _make_contact_value_fast(1.0, 20, contact_b)
+
+    wp.launch(store_roundoff_duplicate_winners_kernel, dim=1, inputs=[reducer_data], device=device)
+
     # Prepare output buffers
     max_output = 100
     contact_pair_out = wp.zeros(max_output, dtype=wp.vec2i, device=device)
@@ -594,10 +625,10 @@ def store_contacts_kernel(
         device=device,
     )
 
-    # Verify output - should have exported all unique winners
+    # Verify output: five distinct pairs plus one representative from the
+    # numerically equivalent winner pair.
     num_exported = int(contact_count_out.numpy()[0])
-
-    test.assertGreater(num_exported, 0)
+    test.assertEqual(num_exported, 6)
 
 
 def test_key_uniqueness(test, device):