refactor: keep Q10 render intermediates internal

Author: tubededentifrice

roborock/map/b01_q10_render.py

@@ -34,7 +34,6 @@
     B01Q10MapParserConfig,
     Q10EraseZone,
     Q10MapPacket,
-    Q10Room,
     Q10TracePacket,
     erased_packet,
 )
@@ -69,13 +68,12 @@ class Q10MapOverlays:
 
 @dataclass
 class Q10MapRender:
-    """The fully composed result of rendering a Q10 map packet.
+    """The image and projected geometry produced by Q10 map composition.
 
     Built by :func:`render_q10_map` from one map packet, trace packet and DPS
-    overlay snapshot, so every derived field is consistent with one set of
-    source inputs. Analogous to
-    :class:`~roborock.map.map_parser.ParsedMapData`, but also carrying the
-    separable :attr:`layers` and derived :attr:`calibration`.
+    overlay snapshot. Source data and intermediate calibration/layer state stay
+    on their owning packet or inside the renderer rather than being repeated on
+    this result.
     """
 
     image_content: bytes
@@ -85,17 +83,6 @@ class Q10MapRender:
     """Parsed map data: image metadata, room names, and -- once a calibration is
     known -- the path / robot position / zones / walls placed in pixel space."""
 
-    layers: GridLayers
-    """Separable map layers (background / wall / floor / per-room) in grid-pixel
-    space, each renderable to a transparent PNG for frontend compositing."""
-
-    rooms: list[Q10Room]
-    """Rooms (segments) reported by the device, with ids and names."""
-
-    calibration: GridCalibration | None
-    """World<->pixel transform used to place the overlays, or ``None`` if no
-    calibration was available (the overlays are then absent from ``map_data``)."""
-
 
 def render_q10_map(
     packet: Q10MapPacket,
@@ -113,17 +100,15 @@ def render_q10_map(
     :class:`RoborockException` if map rendering fails.
     """
     parser = B01Q10MapParser(config)
-    layers = packet.layers
     calibration = solve_q10_calibration(packet, trace)
 
     render_packet = packet
     if calibration is not None:
-        cells = _erased_cells(layers, packet.erase_zones, calibration)
+        cells = _erased_cells(packet.layers, packet.erase_zones, calibration)
         if cells:
-            # Blank the erase-zone cells and re-derive the raster/layers from the
-            # modified packet so the phantom areas disappear (as the app shows).
+            # Blank the erase-zone cells before parsing the raster so phantom
+            # areas disappear (as the app shows).
             render_packet = erased_packet(packet, cells)
-            layers = render_packet.layers
 
     parsed = parser.parsed_from_packet(render_packet)
     if parsed.image_content is None or parsed.map_data is None:
@@ -134,13 +119,7 @@ def render_q10_map(
         _place_trace(map_data, calibration, trace)
         _place_overlays(map_data, calibration, overlays)
 
-    return Q10MapRender(
-        image_content=parsed.image_content,
-        map_data=map_data,
-        layers=layers,
-        rooms=packet.rooms,
-        calibration=calibration,
-    )
+    return Q10MapRender(image_content=parsed.image_content, map_data=map_data)
 
 
 def solve_q10_calibration(
@@ -219,7 +198,9 @@ def _place_trace(
     robot_position = trace.robot_position
     if robot_position is not None:
         px, py = calibration.world_to_pixel(robot_position.x, robot_position.y)
-        map_data.vacuum_position = Point(px, py, trace.heading)
+        # Store the heading in projected image coordinates so drawing does not
+        # need to retain the world-to-pixel calibration.
+        map_data.vacuum_position = Point(px, py, -calibration.y_sign * trace.heading)
     if pixels:
         map_data.charger = pixels[0]
 
@@ -261,11 +242,10 @@ def draw_path_on_map(
 ) -> bytes:
     """Draw the projected ``MapData`` content onto the base map PNG.
 
-    ``render`` must carry its derived calibration. Returns a fresh PNG; the base
-    raster in :attr:`Q10MapRender.image_content` is left untouched.
+    Returns a fresh PNG; the base raster in
+    :attr:`Q10MapRender.image_content` is left untouched.
     """
-    calibration = render.calibration
-    if calibration is None:
+    if render.map_data.path is None:
         raise RoborockException("No calibration available; a cleaning path must be captured during a clean")
 
     scale = config.map_scale
@@ -314,21 +294,15 @@ def to_image(point: Point) -> tuple[float, float]:
         draw.ellipse([cx - radius, cy - radius, cx + radius, cy + radius], fill=position_color)
         robot_heading = robot_position.a
         if robot_heading is not None:
-            # Heading is world-space degrees (0 = +x, +90 = +y). Map a unit
-            # world-space facing vector through the same transform (so the
-            # Y-flip/scale match the marker), then normalize to a fixed
-            # pixel-length tick so it reads at any calibration resolution.
+            # Heading was projected into image coordinates alongside the robot
+            # position, so no calibration state is needed during drawing.
             angle = math.radians(robot_heading)
-            dx = math.cos(angle) / calibration.resolution
-            dy = -calibration.y_sign * math.sin(angle) / calibration.resolution
-            norm = math.hypot(dx, dy)
-            if norm > 0:
-                tick = 4 * radius
-                draw.line(
-                    [cx, cy, cx + dx / norm * tick, cy + dy / norm * tick],
-                    fill=position_color,
-                    width=max(1, scale // 2),
-                )
+            tick = 4 * radius
+            draw.line(
+                [cx, cy, cx + math.cos(angle) * tick, cy + math.sin(angle) * tick],
+                fill=position_color,
+                width=max(1, scale // 2),
+            )
     buffer = io.BytesIO()
     base.save(buffer, format="PNG")
     return buffer.getvalue()

tests/map/test_b01_q10_render.py

@@ -9,8 +9,10 @@
 from dataclasses import replace
 from pathlib import Path
 
+import pytest
 from PIL import Image
 
+from roborock.exceptions import RoborockException
 from roborock.map.b01_grid_layers import GridCalibration
 from roborock.map.b01_q10_map_parser import (
     B01Q10MapParserConfig,
@@ -31,6 +33,7 @@
     _Q10_RESOLUTIONS,
     Q10MapOverlays,
     Q10MapRender,
+    _erased_cells,
     draw_path_on_map,
     render_q10_map,
     solve_q10_calibration,
@@ -92,13 +95,10 @@ def _calibrated_inputs(*, heading: int = 0) -> tuple[Q10MapPacket, Q10TracePacke
 
 
 def test_render_base_map_without_calibration() -> None:
-    """Without a calibration only the base raster/layers/rooms are produced."""
+    """Without a calibration only the base raster is produced."""
     render = _render()
     assert render.image_content[:8] == b"\x89PNG\r\n\x1a\n"
     assert render.map_data is not None
-    assert render.calibration is None
-    assert {room.id: room.name for room in render.rooms} == {2: "Living Room", 3: "Bedroom"}
-    assert render.layers.class_counts.get("floor") == 26
     # Overlays are world-coordinate only, so nothing is placed yet.
     assert render.map_data.path is None
 
@@ -107,13 +107,14 @@ def test_render_places_path_and_position() -> None:
     """The map and trace derive calibration, path and position together."""
     packet, trace = _calibrated_inputs(heading=45)
     render = _render(packet, trace=trace)
-    assert render.calibration is not None
+    calibration = solve_q10_calibration(packet, trace)
+    assert calibration is not None
     assert render.map_data.path is not None
     assert render.map_data.vacuum_position is not None
     assert trace.robot_position is not None
-    expected = render.calibration.world_to_pixel(trace.robot_position.x, trace.robot_position.y)
+    expected = calibration.world_to_pixel(trace.robot_position.x, trace.robot_position.y)
     assert (render.map_data.vacuum_position.x, render.map_data.vacuum_position.y) == expected
-    assert render.map_data.vacuum_position.a == 45
+    assert render.map_data.vacuum_position.a == -45
 
 
 def test_render_places_zones_and_charger() -> None:
@@ -128,43 +129,51 @@ def test_render_places_zones_and_charger() -> None:
     assert len(render.map_data.no_go_areas or []) == 1
     assert len(render.map_data.no_mopping_areas or []) == 1
     assert len(render.map_data.walls or []) == 1
-    assert render.calibration is not None
+    calibration = solve_q10_calibration(packet, trace)
+    assert calibration is not None
     assert render.map_data.charger is not None
-    expected = render.calibration.world_to_pixel(trace.points[0].x, trace.points[0].y)
+    expected = calibration.world_to_pixel(trace.points[0].x, trace.points[0].y)
     assert (render.map_data.charger.x, render.map_data.charger.y) == expected
 
 
 def test_render_applies_erase_zones() -> None:
-    """With a calibration, erase-zone cells are blanked from layers + image."""
+    """With a calibration, erase-zone cells are blanked from the image."""
     packet, trace = _calibrated_inputs()
     base = _render(packet, trace=trace)
-    before_floor = base.layers.class_counts.get("floor")
-    assert before_floor and before_floor > 0
-    assert base.calibration is not None
+    calibration = solve_q10_calibration(packet, trace)
+    assert calibration is not None
 
     # A rectangle covering the whole grid in world coords erases every cell.
     corners = [(-1, -1), (8, -1), (8, 6), (-1, 6)]
-    erase_zone = Q10EraseZone(vertices=_world_vertices(base.calibration, corners))
+    erase_zone = Q10EraseZone(vertices=_world_vertices(calibration, corners))
+    cells = _erased_cells(packet.layers, [erase_zone], calibration)
     render = _render(replace(packet, erase_zones=[erase_zone]), trace=trace)
 
-    assert render.layers.class_counts.get("floor", 0) == 0  # all floor erased
+    assert len(cells) == packet.layers.width * packet.layers.height
     assert render.image_content != base.image_content  # re-rendered
 
 
 def test_render_partial_erase() -> None:
     """An erase rectangle only blanks the cells it covers, leaving the rest."""
     packet, trace = _calibrated_inputs()
     base = _render(packet, trace=trace)
-    before_floor = base.layers.class_counts.get("floor", 0)
-    assert base.calibration is not None
+    calibration = solve_q10_calibration(packet, trace)
+    assert calibration is not None
 
     # Cover only the top two grid rows.
     corners = [(-1, -1), (8, -1), (8, 2), (-1, 2)]
-    erase_zone = Q10EraseZone(vertices=_world_vertices(base.calibration, corners))
+    erase_zone = Q10EraseZone(vertices=_world_vertices(calibration, corners))
+    cells = _erased_cells(packet.layers, [erase_zone], calibration)
     render = _render(replace(packet, erase_zones=[erase_zone]), trace=trace)
 
-    after_floor = render.layers.class_counts.get("floor", 0)
-    assert 0 < after_floor < before_floor  # some, not all, floor removed
+    assert 0 < len(cells) < packet.layers.width * packet.layers.height
+    assert render.image_content != base.image_content
+
+
+def test_draw_path_on_map_requires_projected_path() -> None:
+    """Drawing fails clearly when the source streams could not calibrate."""
+    with pytest.raises(RoborockException, match="No calibration available"):
+        draw_path_on_map(_render(), config=CONFIG)
 
 
 def test_draw_path_on_map_draws_position() -> None: