feat: decode Q10 carpets from the map packet tail

The map (01 01) packet has a vector section after the compressed grid that the
parser previously ignored: [count][vertices_per] + count polygons of int16-BE
(x,y) pairs = carpet areas (user-defined + auto/self-identifying). Confirmed on
two ss07 devices (R1: 3 carpets, RDC: 2) and explains why the dpCarpetUp DP is
empty -- carpets ride in the map, not a DP. parse_map_packet now returns
packet.carpets; MapContentTrait exposes them and, with calibration, rasterises
them into MapData.carpet_map and draws them. The remaining tail (a run-length
raster + trailing signature) is left for later -- likely the carpet pixel mask
and/or obstacles.

roborock/devices/traits/b01/q10/map.py

@@ -29,6 +29,7 @@
 from roborock.map.b01_q10_map_parser import (
     B01Q10MapParser,
     B01Q10MapParserConfig,
+    Q10Carpet,
     Q10Point,
     Q10Room,
     decompose_layers,
@@ -93,6 +94,11 @@ class MapContent(RoborockBase):
     virtual_walls: list[Q10Zone] = field(default_factory=list)
     """Virtual walls (line segments) in world coordinates."""
 
+    carpets: list[Q10Carpet] = field(default_factory=list)
+    """Carpet areas (user-defined + auto-detected) in world coordinates, decoded
+    from the map packet tail. Placed onto ``map_data.carpet_map`` once a
+    calibration is available."""
+
     raw_api_response: bytes | None = None
     """Raw bytes of the map payload from the device (opaque blob for re-parsing)."""
 
@@ -173,7 +179,10 @@ def parse_map_content(self) -> None:
         self.image_content = parsed.image_content
         self.map_data = parsed.map_data
         self.rooms = packet.rooms
+        self.carpets = packet.carpets
         self.layers = decompose_layers(packet)
+        if self.calibration is not None:
+            self._place_zones_on_map_data(self.calibration)
 
     def solve_calibration(self) -> GridCalibration | None:
         """Fit and cache the world<->pixel calibration from the current path.
@@ -238,6 +247,21 @@ def to_area(zone: Q10Zone) -> Area | None:
                 walls.append(Wall(p0[0], p0[1], p1[0], p1[1]))
         self.map_data.walls = walls or None
 
+        # Carpets -> carpet_map (set of pixel indices), filling each rectangle's bbox.
+        if self.carpets and self.layers is not None:
+            width, height = self.layers.width, self.layers.height
+            carpet_cells: set[int] = set()
+            for carpet in self.carpets:
+                pixels = [calibration.world_to_pixel(x, y) for x, y in carpet.vertices]
+                xs = [p[0] for p in pixels]
+                ys = [p[1] for p in pixels]
+                x0, x1 = int(min(xs)), int(max(xs))
+                y0, y1 = int(min(ys)), int(max(ys))
+                for py in range(max(0, y0), min(height, y1 + 1)):
+                    for px in range(max(0, x0), min(width, x1 + 1)):
+                        carpet_cells.add(py * width + px)
+            self.map_data.carpet_map = carpet_cells or None
+
         # The robot starts a session at its dock, so the path origin is the charger.
         if self.path:
             cx, cy = calibration.world_to_pixel(self.path[0].x, self.path[0].y)
@@ -293,6 +317,13 @@ def world_to_image(x: float, y: float) -> tuple[float, float]:
             px, py = calibration.world_to_pixel(x, y)
             return (px * scale, (height - 1 - py) * scale)
 
+        # Carpets (purple, beneath zones).
+        for carpet in self.carpets:
+            if len(carpet.vertices) < 3:
+                continue
+            polygon = [world_to_image(x, y) for x, y in carpet.vertices]
+            draw.polygon(polygon, fill=(150, 90, 220, 60), outline=(120, 60, 190, 200))
+
         # No-go (blue) and no-mop (magenta) zones beneath the path.
         for zone in self.zones:
             if len(zone.vertices) < 3:

roborock/map/b01_q10_map_parser.py

@@ -77,6 +77,8 @@ def decompose_layers(packet: "Q10MapPacket") -> GridLayers:
 _ROOM_RECORD_LENGTH = 47
 _ROOM_NAME_LENGTH_OFFSET = 26
 _MAX_ROOMS = 32
+# Sanity bound for the carpet vector section's vertices-per-polygon field.
+_MAX_CARPET_VERTICES = 16
 
 # Grid cell values >= this are walls / borders rather than room segments.
 _WALL_THRESHOLD = 240
@@ -97,6 +99,16 @@ def name(self) -> str:
         return self.raw_name.removeprefix("rr_").replace("_", " ").strip().title()
 
 
+@dataclass
+class Q10Carpet:
+    """A carpet area (polygon) carried in the map packet, in world coordinates.
+
+    Includes both user-defined and auto-detected ("self-identifying") carpets.
+    """
+
+    vertices: list[tuple[int, int]] = field(default_factory=list)
+
+
 @dataclass
 class Q10MapPacket:
     """Decoded contents of a Q10 ``01 01`` map packet."""
@@ -106,6 +118,8 @@ class Q10MapPacket:
     height: int
     grid: bytes
     rooms: list[Q10Room] = field(default_factory=list)
+    carpets: list[Q10Carpet] = field(default_factory=list)
+    """Carpet areas decoded from the packet tail (world coordinates)."""
 
 
 @dataclass
@@ -295,7 +309,41 @@ def parse_map_packet(payload: bytes) -> Q10MapPacket:
     decoded = lz4_block_decompress(payload[_LAYOUT_COMPRESSED_OFFSET:layout_end])
     height, grid, room_data = _infer_layout(decoded, width)
     rooms = _parse_rooms(room_data, grid)
-    return Q10MapPacket(map_id=map_id, width=width, height=height, grid=grid, rooms=rooms)
+    carpets = _parse_carpets(payload[layout_end:])
+    return Q10MapPacket(map_id=map_id, width=width, height=height, grid=grid, rooms=rooms, carpets=carpets)
+
+
+def _parse_carpets(tail: bytes) -> list[Q10Carpet]:
+    """Decode carpet areas from the bytes after the compressed grid block.
+
+    The tail begins with a vector section ``[count: u8][vertices_per: u8]`` then
+    ``count`` polygons of ``vertices_per`` int16-BE (x, y) pairs (axis-aligned
+    rectangles in practice). Confirmed on two ss07 devices (R1: 3, RDC: 2). The
+    remaining tail (a run-length raster + signature) is not decoded here.
+    """
+    if len(tail) < 2:
+        return []
+    count = tail[0]
+    vertices_per = tail[1]
+    if count == 0 or not 1 <= vertices_per <= _MAX_CARPET_VERTICES:
+        return []
+
+    carpets: list[Q10Carpet] = []
+    offset = 2
+    for _ in range(count):
+        end = offset + vertices_per * 4
+        if end > len(tail):
+            break
+        vertices = [
+            (
+                int.from_bytes(tail[offset + j * 4 : offset + j * 4 + 2], "big", signed=True),
+                int.from_bytes(tail[offset + j * 4 + 2 : offset + j * 4 + 4], "big", signed=True),
+            )
+            for j in range(vertices_per)
+        ]
+        carpets.append(Q10Carpet(vertices=vertices))
+        offset = end
+    return carpets
 
 
 @dataclass

tests/map/test_b01_q10_map_parser.py

@@ -174,6 +174,24 @@ def test_parse_trace_empty_path_has_no_position() -> None:
     assert trace.robot_position is None
 
 
+def test_parse_carpets_from_map_packet_tail() -> None:
+    """Carpet rectangles appended after the grid decode to world polygons."""
+    rects = [
+        [(100, 200), (300, 200), (300, 50), (100, 50)],
+        [(-40, -10), (10, -10), (10, -60), (-40, -60)],
+    ]
+    tail = bytes([len(rects), 4])
+    for rect in rects:
+        for x, y in rect:
+            tail += int.to_bytes(x & 0xFFFF, 2, "big") + int.to_bytes(y & 0xFFFF, 2, "big")
+    packet = parse_map_packet(FIXTURE.read_bytes() + tail)
+    assert [c.vertices for c in packet.carpets] == rects  # incl. signed coords
+
+
+def test_parse_map_packet_without_carpet_tail() -> None:
+    assert parse_map_packet(FIXTURE.read_bytes()).carpets == []
+
+
 def test_parse_trace_rejects_non_trace_packet() -> None:
     with pytest.raises(RoborockException, match="not a Q10 trace packet"):
         parse_trace_packet(_payload())