| import numpy as np |
| from types import SimpleNamespace |
| from gpt6_b1k.visual_navigation import ObservedFloorGrid, forward_clearance, match_features, VisualTracker |
| from gpt6_b1k.sensors import Odometry |
|
|
|
|
| def test_reset_camera_frames_are_not_used_as_visual_anchors(monkeypatch): |
| import io |
| import gpt6_b1k.visual_navigation as nav |
| policy = nav.VisualTrashPolicy(io.StringIO()) |
| obs = SimpleNamespace(kin=None, p=np.zeros(61), hold=lambda: np.ones(23)) |
| monkeypatch.setattr(nav, 'VisualSensors', lambda raw, kin: obs) |
| updates = [] |
| monkeypatch.setattr(policy.tracker, 'update', lambda *args, **kw: updates.append(args[2])) |
| policy.generator = iter([np.zeros(23)]) |
| for _ in range(10): |
| action = policy.predict({}) |
| np.testing.assert_array_equal(action[:3], 0) |
| assert updates == [] |
| policy.predict({}) |
| assert updates == [11] |
|
|
|
|
| def test_active_approach_receives_refined_object_position(monkeypatch): |
| import io |
| import gpt6_b1k.policy as base |
| from gpt6_b1k.visual_navigation import VisualTrashPolicy |
| from gpt6_b1k.perception import Detection |
| policy = VisualTrashPolicy(io.StringIO()) |
| policy.obs = SimpleNamespace() |
| policy.grid.observe = lambda *args: None |
| target = np.array([1., 0., .07]) |
| policy.objects = [dict(point=target, done=False, attempts=0, seen=1)] |
| detection = Detection(center=np.array([1.2, 0., .07]), kind='can', |
| low=np.array([1.16, -.04, 0.]), high=np.array([1.24, .04, .14]), |
| pixels=np.zeros((100, 2)), points=np.zeros((100, 3)), score=.8) |
| monkeypatch.setattr(base, 'floor_objects', lambda obs: [detection]) |
| policy.observe() |
| np.testing.assert_array_equal(target, detection.center) |
| assert policy.objects[0]['point'] is target |
| assert not policy.obs.strict_can_colors |
|
|
|
|
| def test_route_cannot_cross_unobserved_gap(): |
| grid = ObservedFloorGrid(size=80, resolution=.05) |
| grid.seen_floor[10:30, 30:50] = True |
| grid.seen_floor[45:65, 30:50] = True |
| assert grid.route(grid.xy([20, 40]), grid.xy([55, 40])) is None |
| grid.seen_floor[25:50, 30:50] = True |
| grid._allowed = None |
| assert grid.route(grid.xy([20, 40]), grid.xy([55, 40])) is not None |
|
|
|
|
| def test_furniture_clearance_blocks_too_narrow_passage(): |
| grid = ObservedFloorGrid(size=80, resolution=.05) |
| grid.seen_floor[:] = True |
| grid.occupied[:, 30] = True |
| grid.occupied[:, 45] = True |
| assert grid.route(grid.xy([20, 37]), grid.xy([60, 37])) is None |
|
|
|
|
| def test_observed_floor_clears_collected_can_but_keeps_table_above_it(): |
| grid, odom = ObservedFloorGrid(), Odometry() |
| cloud = np.zeros((4, 4, 3)) |
| cloud[0, 0] = [1., 0., .12] |
| cloud[2, 2] = [1., 1., .80] |
| obs = SimpleNamespace(cloud=lambda: cloud, external=lambda points: np.ones(len(points), bool)) |
| grid.observe(obs, odom) |
| can, table = tuple(grid.cell([1., 0.])), tuple(grid.cell([1., 1.])) |
| assert grid.occupied[can] and grid.occupied[table] |
| cloud[0, 0, 2] = cloud[2, 2, 2] = 0. |
| grid.observe(obs, odom) |
| assert not grid.occupied[can] |
| assert grid.occupied[table] |
|
|
|
|
| def test_single_thin_leg_stops_forward_motion(): |
| xyz = np.full((8, 8, 3), 10.) |
| xyz[2, 2] = [.39, .30, .10] |
| obs = SimpleNamespace(cloud=lambda: xyz, external=lambda points: np.ones(len(points), bool)) |
| assert forward_clearance(obs) == .39 |
|
|
|
|
| def test_short_sideways_alignment_checks_its_own_corridor(): |
| xyz = np.full((8, 8, 3), 10.) |
| xyz[2, 2] = [.30, .39, .10] |
| obs = SimpleNamespace(cloud=lambda: xyz, external=lambda points: np.ones(len(points), bool)) |
| assert forward_clearance(obs, direction=[0., 1.]) == .39 |
|
|
|
|
| def test_depth_feature_match_recovers_observed_motion(): |
| rng = np.random.default_rng(4) |
| points = rng.uniform([.6, -1., 0.], [3., 1., 1.], (80, 3)) |
| desc = rng.integers(0, 256, (80, 32), dtype=np.uint8) |
| angle = .08 |
| rot = np.array([[np.cos(angle), -np.sin(angle)], [np.sin(angle), np.cos(angle)]]) |
| current = points.copy() |
| current[:, :2] = current[:, :2]@rot.T + [.06, -.03] |
| current[-15:, :2] += 1. |
| tf, quality = match_features((points, desc), (current, desc)) |
| np.testing.assert_allclose(tf[:2, :2], rot, atol=.001) |
| np.testing.assert_allclose(tf[:2, 3], [.06, -.03], atol=.001) |
| assert quality['inliers'] >= 60 |
|
|
|
|
| def test_failed_visual_match_retains_trusted_anchor(monkeypatch): |
| import gpt6_b1k.visual_navigation as nav |
| empty = (np.empty((0, 3)), None) |
| monkeypatch.setattr(nav, 'visual_features', lambda obs: empty) |
| tracker, odom = VisualTracker(), Odometry() |
| obs = SimpleNamespace(p=np.zeros(61)) |
| tracker.update(obs, odom, 1) |
| anchor = tracker.anchor |
| tracker.update(obs, odom, 5) |
| assert tracker.anchor is anchor and tracker.last_match == 1 |
|
|
|
|
| def test_official_camera_calibration_order_and_privileged_filter(): |
| from gpt6_b1k.visual_navigation import VisualSensors |
| p = np.zeros(61) |
| p[23] = p[48] = 1 |
| poses = np.array([[1., 0, 0, 0, 0, 0, 1], [2., 0, 0, 0, 0, 0, 1], [3., 0, 0, 0, 0, 0, 1]]) |
| obs = VisualSensors({'robot::proprio': p, 'robot::cam_rel_poses': poses.ravel(), |
| 'object_poses': {'forbidden': [99, 99, 99]}, 'q_score': 1.}) |
| for i, camera in enumerate(('left_realsense', 'right_realsense', 'zed'), 1): |
| np.testing.assert_array_equal(obs.camera(camera)[:3, 3], [i, 0, 0]) |
| assert 'object_poses' not in obs.raw and 'q_score' not in obs.raw |
|
|
|
|
| def test_navigation_reaches_goal_between_grid_cells(): |
| import io |
| from gpt6_b1k.visual_navigation import VisualTrashPolicy |
| from gpt6_b1k.sensors import planar |
| policy = VisualTrashPolicy(io.StringIO()) |
| policy.odom.pose = np.array([.05, .05, np.pi/4]) |
| policy.grid.seen_floor[:] = True |
| cloud = np.tile([2., 0., 0.], (8, 8, 1)) |
| policy.obs = SimpleNamespace(hold=lambda: np.zeros(23), cloud=lambda: cloud, |
| external=lambda points: np.ones(len(points), bool)) |
| policy.observe = lambda: None |
| goal = np.array([.125, .125, np.pi/4]) |
| |
| |
| for action in policy.travel(goal): |
| policy.steps += 1 |
| policy.tracker.last_match = policy.steps |
| rotation = planar(policy.odom.pose)[:2, :2] |
| policy.odom.pose[:2] += rotation@action[:2]/30*.75 |
| policy.odom.pose[2] += action[2]/30 |
| assert policy.steps < 200 |
| assert np.linalg.norm(policy.odom.pose[:2]-goal[:2]) < .10 |
|
|
|
|
| def test_discovery_rejects_wood_but_keeps_rich_orange_can(): |
| from gpt6_b1k.perception import floor_objects |
| x, y = np.meshgrid(np.linspace(.70, .77, 20), np.linspace(-.30, -.23, 20)) |
| cloud = np.stack((x, y, np.linspace(.025, .135, 400).reshape(20, 20)), -1) |
| rgb = np.tile([150, 110, 75], (20, 20, 1)) |
| obs = SimpleNamespace(cloud=lambda camera: cloud, get=lambda camera, modality: rgb, |
| eef=lambda arm: np.array([-2., 0., 0.]), strict_can_colors=True) |
| assert not floor_objects(obs) |
| rgb[:] = [220, 95, 12] |
| assert len(floor_objects(obs)) == 1 |
|
|
