[Feature]: Ghost Contacts for Tactile

[Milotrince]

What feature or enhancement are you proposing?

To implement a fast rigid-body based tactile sensor, we will need to be able to query the contact status of arbitrary (point, normal, radius)s in space. These points should not affect collision resolution in the solver, but we should be able to obtain penetration depth, collision area, and direction w.r.t the normal.

Motivation

(image from https://github.com/eanswer/DiffHand )

a bad sketch of what i mean (point, normal, radius) in red, force vector in blue.

Potential Benefit

• Can implement fast tactile array sensors

What is the expected outcome of the implementation work?

• A method in RigidSolver to add a "contact point" (pos, normal, radius)
• A method to query the (force vector, penetration area), on the added points

Additional information

• contype/conaffinity may be useful?

[sunkmechie]

I've been thinking about this and would like to propose that:

We should implement the Ghost Contacts as Kinematic Probes. This ensures that the collision resolution of the physics bodies remains entirely unaffected.

1. We can model each sensor element as a kinematic sphere defined by $S(p, r, \hat{n}_s, k)$:

• $p, r$: World position and sensitive radius.
• $\hat{n}_s$: Sensor Normal
• $k$: Stiffness coefficient (to map penetration depth to a virtual force).

2. Probes check against the existing AABB trees/grid to identify candidate geometries, we use SDFs if available.

3. The sensor state can be quered by using:

• Penetration Depth: $d_{pen} = r - d_{surf}$
• Force Vector: $\vec{F} = k \cdot d_{pen} \cdot \hat{n}_c$. [approximately modeled as a spring-mass system]
• Penetration Area: $$A \approx \pi (2 r d_{pen} - d_{pen}^2)$$ [approx.]

Pseudo-code

def query_contact_points(probes, geometries):
    results = []

    for probe in probes:
        # 1. Initialize result for this probe
        max_penetration = 0.0
        result_force = Vector(0, 0, 0)
        total_area = 0.0
        
        # 2. Broadphase: Get geometries near the probe's bounding sphere
        candidates = broadphase.query_aabb(probe.p, probe.r)
        
        for geom in candidates:
            # 3. Narrowphase: Calculate signed distance and contact normal
            # SDF lookup  GJK/Primitive distance is used otherwise
            dist, contact_normal = collider.compute_distance(geom, probe.p)
            
            # 4. Check for penetration (dist < radius)
            if dist < probe.r:
                # 5. Filter by Sensor Orientation
                # Verify if the contact normal is opposing the sensor's outward face
                if dot_product(contact_normal, probe.n_s) < 0:
                    
                    # Calculate depth: how far the geometry is "inside" the probe sphere
                    d_pen = probe.r - dist
                    
                    # Update metrics
                    if d_pen > max_penetration:
                        max_penetration = d_pen
                    
                    # Approximate contact area using spherical cap formula
                    # A = π * (2rh - h²) where h is penetration depth
                    area = PI * (2 * probe.r * d_pen - d_pen**2)
                    total_area += area
                    
                    # Calculate virtual elastic force: F = k * depth * normal
                    result_force += probe.k * d_pen * contact_normal

        results.append({
            "force": result_force,
            "area": total_area,
            "depth": max_penetration
        })
    
    return results

[Milotrince]

@sunkmechie I like the name "Kinematic Probes". Yes it shouldn't affect the actual collisions. Thanks for the thoughtful write-up!

[sunkmechie]

@sunkmechie I like the name "Kinematic Probes". Yes it shouldn't affect the actual collisions. Thanks for the thoughtful write-up!

Glad that you like the name, 'Kinematic Probe' is a term often used in precision-CNC machine spaces.

Also, once the implementation is complete, should consider writing an optimized gstaichi kernel (if needed).