feat(map): implement Three-Stage Sync and Room ID remapping

- Add Three-Stage Sync (Topology -> Property -> Additive) for robust map editing

- Implement _repopulate_room_ids in TranslationLayer to handle ID changes after splits/merges

- Add spatial room matching (IoU > 0.4) to geometry.py for ID remapping

- Persist VirtualState in RoborockContext to support multi-command editing sessions

- Add CLI commands: map_edit_status, map_edit_sync, map_edit_undo, map_edit_redo, map_edit_clear

- Update map editing CLI commands to utilize the persisted VirtualState

- Add comprehensive unit tests for TranslationLayer and room remapping logic

Entire-Checkpoint: 874f2dac23d3

Author: Coldaine

roborock/cli.py

@@ -179,6 +179,20 @@ def __init__(self):
         self._session_loop: asyncio.AbstractEventLoop | None = None
         self._session_thread: threading.Thread | None = None
         self._device_manager: DeviceConnectionManager | None = None
+        self._virtual_states: dict[str, Any] = {}
+
+    def get_virtual_state(self, device_id: str, map_data: Any = None) -> Any:
+        """Get or create a VirtualState for a device."""
+        from roborock.map import CoordinateTransformer, VirtualState
+        
+        if device_id not in self._virtual_states:
+            if map_data is None:
+                return None
+            
+            transformer = CoordinateTransformer.from_map_data(map_data)
+            self._virtual_states[device_id] = VirtualState(map_data, transformer)
+            
+        return self._virtual_states[device_id]
 
     def reload(self):
         if self.roborock_file.is_file():
@@ -1404,8 +1418,14 @@ async def _execute_edit(device, virtual_state, map_flag: int) -> bool:
         click.echo("ERROR: Device does not have command trait")
         return False
 
+    map_content_trait = getattr(device.v1_properties, 'map_content', None)
+    
     # Create translation layer with proper arguments
-    translation = TranslationLayer(command_trait=command_trait, protocol="v1")
+    translation = TranslationLayer(
+        command_trait=command_trait,
+        map_content_trait=map_content_trait,
+        protocol="v1",
+    )
 
     # Execute edits
     results = await translation.execute_edits(virtual_state, map_flag)
@@ -1521,7 +1541,11 @@ async def split_room(ctx, device_id: str, room: str, direction: str, ratio: floa
     split_line = calculate_split_line(room_bbox, direction, ratio)
 
     # Create virtual state and add edit
-    virtual_state = VirtualState(map_data, transformer)
+    virtual_state = context.get_virtual_state(device_id, map_data)
+    if virtual_state is None:
+        click.echo("Failed to initialize virtual state")
+        return
+    
     edit = SplitRoomEdit(
         segment_id=target_room_id,
         x1=split_line.p1.x,
@@ -1600,7 +1624,11 @@ async def merge_rooms(ctx, device_id: str, rooms: str, apply: bool, preview: boo
             return
 
     transformer = CoordinateTransformer.from_map_data(map_data)
-    virtual_state = VirtualState(map_data, transformer)
+    virtual_state = context.get_virtual_state(device_id, map_data)
+    if virtual_state is None:
+        click.echo("Failed to initialize virtual state")
+        return
+        
     edit = MergeRoomsEdit(segment_ids=segment_ids)
 
     success, error = virtual_state.add_edit(edit)
@@ -1673,7 +1701,11 @@ async def rename_room(ctx, device_id: str, room: str, new_name: str, apply: bool
         return
 
     transformer = CoordinateTransformer.from_map_data(map_data)
-    virtual_state = VirtualState(map_data, transformer)
+    virtual_state = context.get_virtual_state(device_id, map_data)
+    if virtual_state is None:
+        click.echo("Failed to initialize virtual state")
+        return
+        
     edit = RenameRoomEdit(
         segment_id=target_room_id,
         new_name=new_name,
@@ -1736,7 +1768,10 @@ async def add_virtual_wall(ctx, device_id: str, x1: int, y1: int, x2: int, y2: i
 
     map_data = map_trait.map_data
     transformer = CoordinateTransformer.from_map_data(map_data)
-    virtual_state = VirtualState(map_data, transformer)
+    virtual_state = context.get_virtual_state(device_id, map_data)
+    if virtual_state is None:
+        click.echo("Failed to initialize virtual state")
+        return
 
     edit = VirtualWallEdit(x1=float(x1), y1=float(y1), x2=float(x2), y2=float(y2))
 
@@ -1796,7 +1831,10 @@ async def add_no_go_zone(ctx, device_id: str, x1: int, y1: int, x2: int, y2: int
 
     map_data = map_trait.map_data
     transformer = CoordinateTransformer.from_map_data(map_data)
-    virtual_state = VirtualState(map_data, transformer)
+    virtual_state = context.get_virtual_state(device_id, map_data)
+    if virtual_state is None:
+        click.echo("Failed to initialize virtual state")
+        return
 
     edit = NoGoZoneEdit(x1=float(x1), y1=float(y1), x2=float(x2), y2=float(y2))
 
@@ -1821,6 +1859,101 @@ async def add_no_go_zone(ctx, device_id: str, x1: int, y1: int, x2: int, y2: int
         click.echo("\nUse --apply flag to execute the edit")
 
 
+@session.command()
+@click.option("--device_id", required=True, help="Device ID")
+@click.pass_context
+@async_command
+async def map_edit_status(ctx, device_id: str):
+    """Show pending edits in the virtual state."""
+    context: RoborockContext = ctx.obj
+    virtual_state = context.get_virtual_state(device_id)
+
+    if not virtual_state or not virtual_state.has_pending_edits:
+        click.echo("No pending edits")
+        return
+
+    click.echo(f"Pending edits for device {device_id}:")
+    for i, edit in enumerate(virtual_state.pending_edits):
+        click.echo(f"  {i+1}. {edit.edit_type.name} (Status: {edit.status.name})")
+
+
+@session.command()
+@click.option("--device_id", required=True, help="Device ID")
+@click.pass_context
+@async_command
+async def map_edit_sync(ctx, device_id: str):
+    """Sync all pending edits to the device."""
+    context: RoborockContext = ctx.obj
+    virtual_state = context.get_virtual_state(device_id)
+
+    if not virtual_state or not virtual_state.has_pending_edits:
+        click.echo("No pending edits to sync")
+        return
+
+    device_manager = await context.get_device_manager()
+    device = await device_manager.get_device(device_id)
+
+    # We need the map_flag from the base map
+    map_flag = virtual_state._base_map.map_flag if virtual_state._base_map else 0
+
+    success = await _execute_edit(device, virtual_state, map_flag)
+    if success:
+        click.echo("Sync successful. Clearing pending edits.")
+        virtual_state.clear()
+    else:
+        click.echo("Sync failed or partially completed.")
+
+
+@session.command()
+@click.option("--device_id", required=True, help="Device ID")
+@click.pass_context
+@async_command
+async def map_edit_undo(ctx, device_id: str):
+    """Undo the last pending edit."""
+    context: RoborockContext = ctx.obj
+    virtual_state = context.get_virtual_state(device_id)
+
+    if not virtual_state or not virtual_state.can_undo:
+        click.echo("Nothing to undo")
+        return
+
+    edit = virtual_state.undo()
+    click.echo(f"Undone: {edit.edit_type.name}")
+
+
+@session.command()
+@click.option("--device_id", required=True, help="Device ID")
+@click.pass_context
+@async_command
+async def map_edit_redo(ctx, device_id: str):
+    """Redo the last undone edit."""
+    context: RoborockContext = ctx.obj
+    virtual_state = context.get_virtual_state(device_id)
+
+    if not virtual_state or not virtual_state.can_redo:
+        click.echo("Nothing to redo")
+        return
+
+    edit = virtual_state.redo()
+    click.echo(f"Redone: {edit.edit_type.name}")
+
+
+@session.command()
+@click.option("--device_id", required=True, help="Device ID")
+@click.pass_context
+@async_command
+async def map_edit_clear(ctx, device_id: str):
+    """Clear all pending edits."""
+    context: RoborockContext = ctx.obj
+    virtual_state = context.get_virtual_state(device_id)
+
+    if virtual_state:
+        virtual_state.clear()
+        click.echo("Cleared all pending edits")
+    else:
+        click.echo("No virtual state found for this device")
+
+
 def main():
     return cli()
 

roborock/map/editor.py

@@ -509,21 +509,18 @@ def get_edits_by_type(self, edit_type: EditType) -> list[EditObject]:
         """
         return [e for e in self._edit_stack if e.edit_type == edit_type]
 
-    def get_structural_edits(self) -> list[EditObject]:
-        """Get structural edits (split, merge) that must be applied first.
+    def get_topology_edits(self) -> list[EditObject]:
+        """Get topology edits (split, merge) that destroy/create IDs."""
+        topology_types = {EditType.SPLIT_ROOM, EditType.MERGE_ROOMS}
+        return [e for e in self._edit_stack if e.edit_type in topology_types]
 
-        Returns:
-            List of structural edits.
-        """
-        structural_types = {EditType.SPLIT_ROOM, EditType.MERGE_ROOMS, EditType.RENAME_ROOM}
-        return [e for e in self._edit_stack if e.edit_type in structural_types]
+    def get_property_edits(self) -> list[EditObject]:
+        """Get property edits (rename) that depend on current IDs."""
+        property_types = {EditType.RENAME_ROOM, EditType.SET_ROOM_ORDER}
+        return [e for e in self._edit_stack if e.edit_type in property_types]
 
     def get_additive_edits(self) -> list[EditObject]:
-        """Get additive edits (walls, zones) that must be applied after structural.
-
-        Returns:
-            List of additive edits.
-        """
+        """Get additive edits (walls, zones) that use absolute coordinates."""
         additive_types = {
             EditType.VIRTUAL_WALL,
             EditType.NO_GO_ZONE,
@@ -532,6 +529,13 @@ def get_additive_edits(self) -> list[EditObject]:
         }
         return [e for e in self._edit_stack if e.edit_type in additive_types]
 
+    def get_structural_edits(self) -> list[EditObject]:
+        """Deprecated: Use get_topology_edits or get_property_edits instead.
+        
+        Kept for backward compatibility.
+        """
+        return self.get_topology_edits() + self.get_property_edits()
+
     def to_dict(self) -> dict[str, Any]:
         """Serialize the virtual state to a dictionary."""
         return {

roborock/map/geometry.py

@@ -265,6 +265,40 @@ def robot_to_grid(self, point: Point) -> Point:
         )
 
 
+def calculate_room_overlap(box1: BoundingBox, box2: BoundingBox) -> float:
+    """Calculate the overlap ratio between two bounding boxes.
+
+    Uses Intersection over Union (IoU) approach.
+
+    Args:
+        box1: First bounding box.
+        box2: Second bounding box.
+
+    Returns:
+        Ratio of intersection area to union area (0-1).
+    """
+    # Calculate intersection
+    inter_min_x = max(box1.min_x, box2.min_x)
+    inter_max_x = min(box1.max_x, box2.max_x)
+    inter_min_y = max(box1.min_y, box2.min_y)
+    inter_max_y = min(box1.max_y, box2.max_y)
+
+    if inter_max_x < inter_min_x or inter_max_y < inter_min_y:
+        return 0.0
+
+    inter_area = (inter_max_x - inter_min_x) * (inter_max_y - inter_min_y)
+
+    # Calculate union
+    area1 = box1.width * box1.height
+    area2 = box2.width * box2.height
+    union_area = area1 + area2 - inter_area
+
+    if union_area <= 0:
+        return 0.0
+
+    return inter_area / union_area
+
+
 def calculate_split_line(
     bounding_box: BoundingBox,
     direction: str = "vertical",