| """Grader for the nut_thread scene: every nut seated on a bolt.
|
|
|
| Rubric stages (weights and modes live in RUBRIC), each a fraction over that env's nuts:
|
| lifted nuts ever raised to the bolt-top rest height — origin at/above `bolt_height`
|
| in the nearest bolt's frame, the height the scene quotes for a nut resting on
|
| the bolt top and so the height a nut has to clear before it can be set on the
|
| bolt — or already aligned on a bolt (a nut on the bolt was necessarily lifted
|
| there); a milestone, latched per nut
|
| aligned nuts aligned on a bolt — within `align_xy` of the bolt axis and tilted at most
|
| `align_axis_deg` off it, the scene's own two non-depth seat gates
|
| threaded mean thread depth from the bolt-top rest height (`bolt_height`) down to the
|
| seat (`seat_z`), counted only while aligned — so a nut's value is 1.0 iff the
|
| scene calls it seated
|
| The rungs nest (seated => aligned => lifted), so progress reaches 1.0 exactly when every
|
| nut of the env is seated, and for a grader built after the pick as well as one that watched
|
| it. Success is the scene's `seated()` per env, read when the delivery finishes.
|
| """
|
|
|
| from __future__ import annotations
|
|
|
| import math
|
|
|
| from robobench.core import BaseGrader
|
| from robobench.suites.assembly.scenes.nut_thread_assembly import NutThreadAssemblyScene
|
|
|
|
|
| class NutThreadAssemblyGrader(BaseGrader):
|
| """Every nut seated — threaded down to seat depth, on the bolt axis, upright.
|
|
|
| Ladder: lifted 0.33 · aligned 0.67 · threaded 1.00 — three equal rungs for the three
|
| steps of the task (pick the nut up, set it on the bolt, screw it down); the last rung
|
| is a linear ramp of the nut's height from the bolt-top rest height (`bolt_height`) to
|
| the seat (`seat_z`). With N nuts every stage is the fraction of nuts.
|
| """
|
|
|
| SCENE = NutThreadAssemblyScene
|
| RUBRIC = (("lifted", 1, "once"), ("aligned", 1), ("threaded", 1))
|
| scene: NutThreadAssemblyScene
|
|
|
| def setup(self) -> None:
|
| import torch
|
|
|
| z, _, _ = self._on_bolt()
|
| self._lifted = torch.zeros_like(z, dtype=torch.bool)
|
|
|
| def check_success(self):
|
| return self.scene.seated().all(dim=1)
|
|
|
| def _on_bolt(self):
|
| """(height, aligned, thread), each (num_envs, num_nuts): the nut origin's height
|
| above its nearest bolt's origin, whether it passes the scene's xy + tilt seat gates,
|
| and its thread-depth fraction from the bolt-top rest height to the seat."""
|
| import torch
|
|
|
| c = self.scene.cfg
|
| off = self.scene._nut_offsets_in_bolt()
|
| near_dist, near = off[..., :2].norm(dim=-1).min(dim=-1)
|
| z = torch.gather(off[..., 2], 2, near.unsqueeze(-1)).squeeze(-1)
|
| aligned = (near_dist <= c.align_xy) & (
|
| self.scene._nut_axis_cos() >= math.cos(math.radians(c.align_axis_deg)))
|
| thread = ((c.bolt_height - z) / (c.bolt_height - c.seat_z)).clamp(0.0, 1.0)
|
| return z, aligned, thread
|
|
|
|
|
|
|
| def lifted(self):
|
| z, aligned, _ = self._on_bolt()
|
| self._lifted |= (z >= self.scene.cfg.bolt_height) | aligned
|
| return self._lifted.float().mean(dim=1)
|
|
|
| def aligned(self):
|
| _, aligned, _ = self._on_bolt()
|
| return aligned.float().mean(dim=1)
|
|
|
| def threaded(self):
|
| _, aligned, thread = self._on_bolt()
|
| return (aligned * thread).mean(dim=1)
|
|
|
