valetudo-map-parser 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

valetudo_map_parser/__init__.py

@@ -1,7 +1,9 @@
 """Valetudo map parser.
-Version: 0.1.4"""
+Version: 0.1.6"""
 
 from .hypfer_handler import HypferMapImageHandler
+from .rand25_handler import ReImageHandler
+from .config.rand25_parser import RRMapParser
 from .config.shared import CameraShared, CameraSharedManager
 from .config.colors import ColorsManagment
 from .config.drawable import Drawable
@@ -16,6 +18,7 @@ from .config.types import (
 
 __all__ = [
     "HypferMapImageHandler",
+    "ReImageHandler",
     "CameraShared",
     "CameraSharedManager",
     "ColorsManagment",

valetudo_map_parser/config/rand25_parser.py

@@ -0,0 +1,398 @@
+"""
+Version: v2024.08.2
+- This parser is the python version of @rand256 valetudo_mapper.
+- This class is extracting the vacuum binary map_data.
+- Additional functions are to get in our image_handler the images datas.
+"""
+
+from enum import Enum
+import math
+import struct
+from typing import Dict, List, Optional, Callable, TypeVar, Any
+
+_CallableT = TypeVar("_CallableT", bound=Callable[..., Any])
+
+
+def callback(func: _CallableT) -> _CallableT:
+    """Annotation to mark method as safe to call from within the event loop."""
+    setattr(func, "_hass_callback", True)  # Attach a custom attribute to the function
+    return func  # Return the function without modifying its behavior
+
+
+# noinspection PyTypeChecker
+class RRMapParser:
+    """Parse the map data from the Rand256 vacuum."""
+
+    def __init__(self):
+        self.map_data = None
+
+    class Tools:
+        """Tools for the RRMapParser."""
+
+        DIMENSION_PIXELS = 1024
+        DIMENSION_MM = 50 * 1024
+
+    class Types(Enum):
+        """Types of blocks in the RRMapParser."""
+
+        CHARGER_LOCATION = 1
+        IMAGE = 2
+        PATH = 3
+        GOTO_PATH = 4
+        GOTO_PREDICTED_PATH = 5
+        CURRENTLY_CLEANED_ZONES = 6
+        GOTO_TARGET = 7
+        ROBOT_POSITION = 8
+        FORBIDDEN_ZONES = 9
+        VIRTUAL_WALLS = 10
+        CURRENTLY_CLEANED_BLOCKS = 11
+        FORBIDDEN_MOP_ZONES = 12
+        DIGEST = 1024
+
+    @staticmethod
+    def parse_block(
+        buf: bytes,
+        offset: int,
+        result: Optional[Dict[int, Any]] = None,
+        pixels: bool = False,
+    ) -> Dict[int, Any]:
+        """Parse a block of data from the map data."""
+        result = result or {}
+        if len(buf) <= offset:
+            return result
+
+        type_ = struct.unpack("<H", buf[offset : offset + 2])[0]
+        hlength = struct.unpack("<H", buf[offset + 2 : offset + 4])[0]
+        length = struct.unpack("<I", buf[offset + 4 : offset + 8])[0]
+
+        if type_ in (
+            RRMapParser.Types.ROBOT_POSITION.value,
+            RRMapParser.Types.CHARGER_LOCATION.value,
+        ):
+            result[type_] = {
+                "position": [
+                    int.from_bytes(buf[offset + 8 : offset + 10], byteorder="little"),
+                    int.from_bytes(buf[offset + 12 : offset + 14], byteorder="little"),
+                ],
+                "angle": (
+                    struct.unpack("<i", buf[offset + 16 : offset + 20])[0]
+                    if length >= 12
+                    else 0
+                ),
+            }
+        elif type_ == RRMapParser.Types.IMAGE.value:
+            RRMapParser._parse_image_block(buf, offset, length, hlength, result, pixels)
+        elif type_ in (
+            RRMapParser.Types.PATH.value,
+            RRMapParser.Types.GOTO_PATH.value,
+            RRMapParser.Types.GOTO_PREDICTED_PATH.value,
+        ):
+            result[type_] = RRMapParser._parse_path_block(buf, offset, length)
+        elif type_ == RRMapParser.Types.GOTO_TARGET.value:
+            result[type_] = {
+                "position": [
+                    struct.unpack("<H", buf[offset + 8 : offset + 10])[0],
+                    struct.unpack("<H", buf[offset + 10 : offset + 12])[0],
+                ]
+            }
+        elif type_ == RRMapParser.Types.CURRENTLY_CLEANED_ZONES.value:
+            result[type_] = RRMapParser._parse_cleaned_zones(buf, offset, length)
+        elif type_ in (
+            RRMapParser.Types.FORBIDDEN_ZONES.value,
+            RRMapParser.Types.FORBIDDEN_MOP_ZONES.value,
+            RRMapParser.Types.VIRTUAL_WALLS.value,
+        ):
+            result[type_] = RRMapParser._parse_forbidden_zones(buf, offset, length)
+        return RRMapParser.parse_block(buf, offset + length + hlength, result, pixels)
+
+    @staticmethod
+    def _parse_image_block(
+        buf: bytes,
+        offset: int,
+        length: int,
+        hlength: int,
+        result: Dict[int, Any],
+        pixels: bool,
+    ) -> None:
+        """Parse the image block of the map data."""
+        g3offset = 4 if hlength > 24 else 0
+        parameters = {
+            "segments": {
+                "count": (
+                    struct.unpack("<i", buf[offset + 8 : offset + 12])[0]
+                    if g3offset
+                    else 0
+                ),
+                "id": [],
+            },
+            "position": {
+                "top": struct.unpack(
+                    "<i", buf[offset + 8 + g3offset : offset + 12 + g3offset]
+                )[0],
+                "left": struct.unpack(
+                    "<i", buf[offset + 12 + g3offset : offset + 16 + g3offset]
+                )[0],
+            },
+            "dimensions": {
+                "height": struct.unpack(
+                    "<i", buf[offset + 16 + g3offset : offset + 20 + g3offset]
+                )[0],
+                "width": struct.unpack(
+                    "<i", buf[offset + 20 + g3offset : offset + 24 + g3offset]
+                )[0],
+            },
+            "pixels": {"floor": [], "walls": [], "segments": {}},
+        }
+        parameters["position"]["top"] = (
+            RRMapParser.Tools.DIMENSION_PIXELS
+            - parameters["position"]["top"]
+            - parameters["dimensions"]["height"]
+        )
+        if (
+            parameters["dimensions"]["height"] > 0
+            and parameters["dimensions"]["width"] > 0
+        ):
+            for i in range(length):
+                segment_type = (
+                    struct.unpack(
+                        "<B",
+                        buf[offset + 24 + g3offset + i : offset + 25 + g3offset + i],
+                    )[0]
+                    & 0x07
+                )
+                if segment_type == 0:
+                    continue
+                elif segment_type == 1 and pixels:
+                    parameters["pixels"]["walls"].append(i)
+                else:
+                    s = (
+                        struct.unpack(
+                            "<B",
+                            buf[
+                                offset + 24 + g3offset + i : offset + 25 + g3offset + i
+                            ],
+                        )[0]
+                        >> 3
+                    )
+                    if s == 0 and pixels:
+                        parameters["pixels"]["floor"].append(i)
+                    elif s != 0:
+                        if s not in parameters["segments"]["id"]:
+                            parameters["segments"]["id"].append(s)
+                            parameters["segments"]["pixels_seg_" + str(s)] = []
+                        if pixels:
+                            parameters["segments"]["pixels_seg_" + str(s)].append(i)
+        result[RRMapParser.Types.IMAGE.value] = parameters
+
+    @staticmethod
+    def _parse_path_block(buf: bytes, offset: int, length: int) -> Dict[str, Any]:
+        """Parse a path block of the map data."""
+        points = [
+            [
+                struct.unpack("<H", buf[offset + 20 + i : offset + 22 + i])[0],
+                struct.unpack("<H", buf[offset + 22 + i : offset + 24 + i])[0],
+            ]
+            for i in range(0, length, 4)
+        ]
+        return {
+            "current_angle": struct.unpack("<I", buf[offset + 16 : offset + 20])[0],
+            "points": points,
+        }
+
+    @staticmethod
+    def _parse_cleaned_zones(buf: bytes, offset: int, length: int) -> List[List[int]]:
+        """Parse the cleaned zones block of the map data."""
+        zone_count = struct.unpack("<I", buf[offset + 8 : offset + 12])[0]
+        return (
+            [
+                [
+                    struct.unpack("<H", buf[offset + 12 + i : offset + 14 + i])[0],
+                    struct.unpack("<H", buf[offset + 14 + i : offset + 16 + i])[0],
+                    struct.unpack("<H", buf[offset + 16 + i : offset + 18 + i])[0],
+                    struct.unpack("<H", buf[offset + 18 + i : offset + 20 + i])[0],
+                ]
+                for i in range(0, length, 8)
+            ]
+            if zone_count > 0
+            else []
+        )
+
+    @staticmethod
+    def _parse_forbidden_zones(buf: bytes, offset: int, length: int) -> List[List[int]]:
+        """Parse the forbidden zones block of the map data."""
+        zone_count = struct.unpack("<I", buf[offset + 8 : offset + 12])[0]
+        return (
+            [
+                [
+                    struct.unpack("<H", buf[offset + 12 + i : offset + 14 + i])[0],
+                    struct.unpack("<H", buf[offset + 14 + i : offset + 16 + i])[0],
+                    struct.unpack("<H", buf[offset + 16 + i : offset + 18 + i])[0],
+                    struct.unpack("<H", buf[offset + 18 + i : offset + 20 + i])[0],
+                    struct.unpack("<H", buf[offset + 20 + i : offset + 22 + i])[0],
+                    struct.unpack("<H", buf[offset + 22 + i : offset + 24 + i])[0],
+                    struct.unpack("<H", buf[offset + 24 + i : offset + 26 + i])[0],
+                    struct.unpack("<H", buf[offset + 26 + i : offset + 28 + i])[0],
+                ]
+                for i in range(0, length, 16)
+            ]
+            if zone_count > 0
+            else []
+        )
+
+    @callback
+    def parse(self, map_buf: bytes) -> Dict[str, Any]:
+        """Parse the map data."""
+        if map_buf[0:2] == b"rr":
+            return {
+                "header_length": struct.unpack("<H", map_buf[2:4])[0],
+                "data_length": struct.unpack("<H", map_buf[4:6])[0],
+                "version": {
+                    "major": struct.unpack("<H", map_buf[8:10])[0],
+                    "minor": struct.unpack("<H", map_buf[10:12])[0],
+                },
+                "map_index": struct.unpack("<H", map_buf[12:14])[0],
+                "map_sequence": struct.unpack("<H", map_buf[16:18])[0],
+            }
+        return {}
+
+    @callback
+    def parse_rrm_data(
+        self, map_buf: bytes, pixels: bool = False
+    ) -> Optional[Dict[str, Any]]:
+        """Parse the complete map data."""
+        if not self.parse(map_buf).get("map_index"):
+            return None
+
+        parsed_map_data = {}
+        blocks = self.parse_block(map_buf, 0x14, None, pixels)
+
+        if RRMapParser.Types.IMAGE.value in blocks:
+            parsed_map_data["image"] = blocks[RRMapParser.Types.IMAGE.value]
+            for item in [
+                {"type": RRMapParser.Types.PATH.value, "path": "path"},
+                {
+                    "type": RRMapParser.Types.GOTO_PREDICTED_PATH.value,
+                    "path": "goto_predicted_path",
+                },
+            ]:
+                if item["type"] in blocks:
+                    parsed_map_data[item["path"]] = blocks[item["type"]]
+                    parsed_map_data[item["path"]]["points"] = [
+                        [point[0], RRMapParser.Tools.DIMENSION_MM - point[1]]
+                        for point in parsed_map_data[item["path"]]["points"]
+                    ]
+                    if len(parsed_map_data[item["path"]]["points"]) >= 2:
+                        parsed_map_data[item["path"]]["current_angle"] = math.degrees(
+                            math.atan2(
+                                parsed_map_data[item["path"]]["points"][-1][1]
+                                - parsed_map_data[item["path"]]["points"][-2][1],
+                                parsed_map_data[item["path"]]["points"][-1][0]
+                                - parsed_map_data[item["path"]]["points"][-2][0],
+                            )
+                        )
+        if RRMapParser.Types.CHARGER_LOCATION.value in blocks:
+            charger = blocks[RRMapParser.Types.CHARGER_LOCATION.value]["position"]
+            # Assume no transformation needed here
+            parsed_map_data["charger"] = charger
+
+        if RRMapParser.Types.ROBOT_POSITION.value in blocks:
+            robot = blocks[RRMapParser.Types.ROBOT_POSITION.value]["position"]
+            rob_angle = blocks[RRMapParser.Types.ROBOT_POSITION.value]["angle"]
+            # Assume no transformation needed here
+            parsed_map_data["robot"] = robot
+            parsed_map_data["robot_angle"] = rob_angle
+
+        if RRMapParser.Types.GOTO_TARGET.value in blocks:
+            parsed_map_data["goto_target"] = blocks[
+                RRMapParser.Types.GOTO_TARGET.value
+            ]["position"]
+            # Assume no transformation needed here
+
+        if RRMapParser.Types.CURRENTLY_CLEANED_ZONES.value in blocks:
+            parsed_map_data["currently_cleaned_zones"] = blocks[
+                RRMapParser.Types.CURRENTLY_CLEANED_ZONES.value
+            ]
+            parsed_map_data["currently_cleaned_zones"] = [
+                [
+                    zone[0],
+                    RRMapParser.Tools.DIMENSION_MM - zone[1],
+                    zone[2],
+                    RRMapParser.Tools.DIMENSION_MM - zone[3],
+                ]
+                for zone in parsed_map_data["currently_cleaned_zones"]
+            ]
+
+        if RRMapParser.Types.FORBIDDEN_ZONES.value in blocks:
+            parsed_map_data["forbidden_zones"] = blocks[
+                RRMapParser.Types.FORBIDDEN_ZONES.value
+            ]
+            parsed_map_data["forbidden_zones"] = [
+                [
+                    zone[0],
+                    RRMapParser.Tools.DIMENSION_MM - zone[1],
+                    zone[2],
+                    RRMapParser.Tools.DIMENSION_MM - zone[3],
+                    zone[4],
+                    RRMapParser.Tools.DIMENSION_MM - zone[5],
+                    zone[6],
+                    RRMapParser.Tools.DIMENSION_MM - zone[7],
+                ]
+                for zone in parsed_map_data["forbidden_zones"]
+            ]
+
+        if RRMapParser.Types.VIRTUAL_WALLS.value in blocks:
+            parsed_map_data["virtual_walls"] = blocks[
+                RRMapParser.Types.VIRTUAL_WALLS.value
+            ]
+            parsed_map_data["virtual_walls"] = [
+                [
+                    wall[0],
+                    RRMapParser.Tools.DIMENSION_MM - wall[1],
+                    wall[2],
+                    RRMapParser.Tools.DIMENSION_MM - wall[3],
+                ]
+                for wall in parsed_map_data["virtual_walls"]
+            ]
+
+        if RRMapParser.Types.CURRENTLY_CLEANED_BLOCKS.value in blocks:
+            parsed_map_data["currently_cleaned_blocks"] = blocks[
+                RRMapParser.Types.CURRENTLY_CLEANED_BLOCKS.value
+            ]
+
+        if RRMapParser.Types.FORBIDDEN_MOP_ZONES.value in blocks:
+            parsed_map_data["forbidden_mop_zones"] = blocks[
+                RRMapParser.Types.FORBIDDEN_MOP_ZONES.value
+            ]
+            parsed_map_data["forbidden_mop_zones"] = [
+                [
+                    zone[0],
+                    RRMapParser.Tools.DIMENSION_MM - zone[1],
+                    zone[2],
+                    RRMapParser.Tools.DIMENSION_MM - zone[3],
+                    zone[4],
+                    RRMapParser.Tools.DIMENSION_MM - zone[5],
+                    zone[6],
+                    RRMapParser.Tools.DIMENSION_MM - zone[7],
+                ]
+                for zone in parsed_map_data["forbidden_mop_zones"]
+            ]
+
+        return parsed_map_data
+
+    def parse_data(
+        self, payload: Optional[bytes] = None, pixels: bool = False
+    ) -> Optional[Dict[str, Any]]:
+        """Get the map data from MQTT and return the json."""
+        if payload:
+            self.map_data = self.parse(payload)
+            self.map_data.update(self.parse_rrm_data(payload, pixels) or {})
+        return self.map_data
+
+    def get_image(self) -> Dict[str, Any]:
+        """Get the image data from the map data."""
+        return self.map_data.get("image", {})
+
+    @staticmethod
+    def get_int32(data: bytes, address: int) -> int:
+        """Get a 32-bit integer from the data."""
+        return struct.unpack_from("<i", data, address)[0]

valetudo_map_parser/map_data.py

@@ -3,12 +3,11 @@ Collections of Json and List routines
 ImageData is part of the Image_Handler
 used functions to search data in the json
 provided for the creation of the new camera frame
-Version: v2024.08.0
+Version: v0.1.6
 """
 
 from __future__ import annotations
 
-from typing import Any
 import numpy as np
 
 from .config.types import (
@@ -186,7 +185,7 @@ class ImageData:
             if rand:
                 x, y, _ = entry  # Extract x and y coordinates
                 max_x = max(max_x, x)  # Update max x coordinate
-                max_y = max(max_y, y)  # Update max y coordinate
+                max_y = max(max_y, y + pixel_size)  # Update max y coordinate
                 min_x = min(min_x, x)  # Update min x coordinate
                 min_y = min(min_y, y)  # Update min y coordinate
             else:
@@ -227,7 +226,7 @@ class ImageData:
         compressed_pixels = []
 
         tot_pixels = 0
-        current_x, current_y, count = None, None, 0  # pylint: disable=unused-variable
+        current_x, current_y, count = None, None, 0
         for index in pixel_data:
             x = (index % image_width) + image_left
             y = ((image_height - 1) - (index // image_width)) + image_top

valetudo_map_parser/rand25_handler.py

@@ -0,0 +1,455 @@
+"""
+Image Handler Module for Valetudo Re Vacuums.
+It returns the PIL PNG image frame relative to the Map Data extrapolated from the vacuum json.
+It also returns calibration, rooms data to the card and other images information to the camera.
+Version: v2024.12.0
+"""
+
+from __future__ import annotations
+
+import logging
+import uuid
+
+from PIL import Image, ImageOps
+
+from .config.types import COLORS, DEFAULT_IMAGE_SIZE, DEFAULT_PIXEL_SIZE
+from .config.types import Colors, JsonType, PilPNG, RobotPosition, RoomsProperties
+from .config.auto_crop import AutoCrop
+from images_utils import ImageUtils as ImUtils
+from map_data import ImageData
+from reimg_draw import ImageDraw
+
+_LOGGER = logging.getLogger(__name__)
+
+
+# noinspection PyTypeChecker
+class ReImageHandler(object):
+    """
+    Image Handler for Valetudo Re Vacuums.
+    """
+
+    def __init__(self, camera_shared):
+        self.auto_crop = None  # Auto crop flag
+        self.segment_data = None  # Segment data
+        self.outlines = None  # Outlines data
+        self.calibration_data = None  # Calibration data
+        self.charger_pos = None  # Charger position
+        self.crop_area = None  # Crop area
+        self.crop_img_size = None  # Crop image size
+        self.data = ImageData  # Image Data
+        self.frame_number = 0  # Image Frame number
+        self.max_frames = 1024
+        self.go_to = None  # Go to position data
+        self.img_base_layer = None  # Base image layer
+        self.img_rotate = camera_shared.image_rotate  # Image rotation
+        self.img_size = None  # Image size
+        self.json_data = None  # Json data
+        self.json_id = None  # Json id
+        self.path_pixels = None  # Path pixels data
+        self.robot_in_room = None  # Robot in room data
+        self.robot_pos = None  # Robot position
+        self.room_propriety = None  # Room propriety data
+        self.rooms_pos = None  # Rooms position data
+        self.shared = camera_shared  # Shared data
+        self.active_zones = None  # Active zones
+        self.trim_down = None  # Trim down
+        self.trim_left = None  # Trim left
+        self.trim_right = None  # Trim right
+        self.trim_up = None  # Trim up
+        self.zooming = False  # Zooming flag
+        self.file_name = self.shared.file_name  # File name
+        self.offset_x = 0  # offset x for the aspect ratio.
+        self.offset_y = 0  # offset y for the aspect ratio.
+        self.offset_top = self.shared.offset_top  # offset top
+        self.offset_bottom = self.shared.offset_down  # offset bottom
+        self.offset_left = self.shared.offset_left  # offset left
+        self.offset_right = self.shared.offset_right  # offset right
+        self.imd = ImageDraw(self)  # Image Draw
+        self.imu = ImUtils(self)  # Image Utils
+        self.ac = AutoCrop(self)
+
+    async def extract_room_properties(
+        self, json_data: JsonType, destinations: JsonType
+    ) -> RoomsProperties:
+        """Extract the room properties."""
+        unsorted_id = ImageData.get_rrm_segments_ids(json_data)
+        size_x, size_y = ImageData.get_rrm_image_size(json_data)
+        top, left = ImageData.get_rrm_image_position(json_data)
+        try:
+            if not self.segment_data or not self.outlines:
+                (
+                    self.segment_data,
+                    self.outlines,
+                ) = await ImageData.async_get_rrm_segments(
+                    json_data, size_x, size_y, top, left, True
+                )
+            dest_json = destinations
+            room_data = dict(dest_json).get("rooms", [])
+            zones_data = dict(dest_json).get("zones", [])
+            points_data = dict(dest_json).get("spots", [])
+            room_id_to_data = {room["id"]: room for room in room_data}
+            self.rooms_pos = []
+            room_properties = {}
+            if self.outlines:
+                for id_x, room_id in enumerate(unsorted_id):
+                    if room_id in room_id_to_data:
+                        room_info = room_id_to_data[room_id]
+                        name = room_info.get("name")
+                        # Calculate x and y min/max from outlines
+                        x_min = self.outlines[id_x][0][0]
+                        x_max = self.outlines[id_x][1][0]
+                        y_min = self.outlines[id_x][0][1]
+                        y_max = self.outlines[id_x][1][1]
+                        corners = [
+                            (x_min, y_min),
+                            (x_max, y_min),
+                            (x_max, y_max),
+                            (x_min, y_max),
+                        ]
+                        # rand256 vacuums accept int(room_id) or str(name)
+                        # the card will soon support int(room_id) but the camera will send name
+                        # this avoids the manual change of the values in the card.
+                        self.rooms_pos.append(
+                            {
+                                "name": name,
+                                "corners": corners,
+                            }
+                        )
+                        room_properties[int(room_id)] = {
+                            "number": int(room_id),
+                            "outline": corners,
+                            "name": name,
+                            "x": (x_min + x_max) // 2,
+                            "y": (y_min + y_max) // 2,
+                        }
+                # get the zones and points data
+                zone_properties = await self.imu.async_zone_propriety(zones_data)
+                # get the points data
+                point_properties = await self.imu.async_points_propriety(points_data)
+
+                if room_properties != {}:
+                    if zone_properties != {}:
+                        _LOGGER.debug("Rooms and Zones, data extracted!")
+                    else:
+                        _LOGGER.debug("Rooms, data extracted!")
+                elif zone_properties != {}:
+                    _LOGGER.debug("Zones, data extracted!")
+                else:
+                    self.rooms_pos = None
+                    _LOGGER.debug(
+                        f"{self.file_name}: Rooms and Zones data not available!"
+                    )
+                return room_properties, zone_properties, point_properties
+        except Exception as e:
+            _LOGGER.debug(
+                f"No rooms Data or Error in extract_room_properties: {e}",
+                exc_info=True,
+            )
+            return None, None, None
+
+    async def get_image_from_rrm(
+        self,
+        m_json: JsonType,  # json data
+        destinations: None = None,  # MQTT destinations for labels
+    ) -> PilPNG or None:
+        """Generate Images from the json data."""
+        colors: Colors = {
+            name: self.shared.user_colors[idx] for idx, name in enumerate(COLORS)
+        }
+        self.active_zones = self.shared.rand256_active_zone
+
+        try:
+            if (m_json is not None) and (not isinstance(m_json, tuple)):
+                _LOGGER.info(f"{self.file_name}: Composing the image for the camera.")
+                # buffer json data
+                self.json_data = m_json
+                # get the image size
+                size_x, size_y = self.data.get_rrm_image_size(m_json)
+                ##########################
+                self.img_size = DEFAULT_IMAGE_SIZE
+                ###########################
+                self.json_id = str(uuid.uuid4())  # image id
+                _LOGGER.info(f"Vacuum Data ID: {self.json_id}")
+                # get the robot position
+                (
+                    robot_pos,
+                    robot_position,
+                    robot_position_angle,
+                ) = await self.imd.async_get_robot_position(m_json)
+                if self.frame_number == 0:
+                    room_id, img_np_array = await self.imd.async_draw_base_layer(
+                        m_json,
+                        size_x,
+                        size_y,
+                        colors["wall"],
+                        colors["zone_clean"],
+                        colors["background"],
+                        DEFAULT_PIXEL_SIZE,
+                    )
+                    _LOGGER.info(f"{self.file_name}: Completed base Layers")
+                    if (room_id > 0) and not self.room_propriety:
+                        self.room_propriety = await self.get_rooms_attributes(
+                            destinations
+                        )
+                        if self.rooms_pos:
+                            self.robot_pos = await self.async_get_robot_in_room(
+                                (robot_position[0] * 10),
+                                (robot_position[1] * 10),
+                                robot_position_angle,
+                            )
+                    self.img_base_layer = await self.imd.async_copy_array(img_np_array)
+
+                # If there is a zone clean we draw it now.
+                self.frame_number += 1
+                img_np_array = await self.imd.async_copy_array(self.img_base_layer)
+                _LOGGER.debug(f"{self.file_name}: Frame number {self.frame_number}")
+                if self.frame_number > 5:
+                    self.frame_number = 0
+                # All below will be drawn each time
+                # charger
+                img_np_array, self.charger_pos = await self.imd.async_draw_charger(
+                    img_np_array, m_json, colors["charger"]
+                )
+                # zone clean
+                img_np_array = await self.imd.async_draw_zones(
+                    m_json, img_np_array, colors["zone_clean"]
+                )
+                # virtual walls
+                img_np_array = await self.imd.async_draw_virtual_restrictions(
+                    m_json, img_np_array, colors["no_go"]
+                )
+                # draw path
+                img_np_array = await self.imd.async_draw_path(
+                    img_np_array, m_json, colors["move"]
+                )
+                # go to flag and predicted path
+                await self.imd.async_draw_go_to_flag(
+                    img_np_array, m_json, colors["go_to"]
+                )
+                # draw the robot
+                img_np_array = await self.imd.async_draw_robot_on_map(
+                    img_np_array, robot_position, robot_position_angle, colors["robot"]
+                )
+                _LOGGER.debug(
+                    f"{self.file_name}:"
+                    f" Auto cropping the image with rotation {int(self.shared.image_rotate)}"
+                )
+                img_np_array = await self.ac.async_auto_trim_and_zoom_image(
+                    img_np_array,
+                    colors["background"],
+                    int(self.shared.margins),
+                    int(self.shared.image_rotate),
+                    self.zooming,
+                    rand256=True,
+                )
+                pil_img = Image.fromarray(img_np_array, mode="RGBA")
+                del img_np_array  # free memory
+                # reduce the image size if the zoomed image is bigger then the original.
+                if (
+                    self.shared.image_auto_zoom
+                    and self.shared.vacuum_state == "cleaning"
+                    and self.zooming
+                    and self.shared.image_zoom_lock_ratio
+                    or self.shared.image_aspect_ratio != "None"
+                ):
+                    width = self.shared.image_ref_width
+                    height = self.shared.image_ref_height
+                    if self.shared.image_aspect_ratio != "None":
+                        wsf, hsf = [
+                            int(x) for x in self.shared.image_aspect_ratio.split(",")
+                        ]
+                        _LOGGER.debug(f"Aspect Ratio: {wsf}, {hsf}")
+                        if wsf == 0 or hsf == 0:
+                            return pil_img
+                        new_aspect_ratio = wsf / hsf
+                        aspect_ratio = width / height
+                        if aspect_ratio > new_aspect_ratio:
+                            new_width = int(pil_img.height * new_aspect_ratio)
+                            new_height = pil_img.height
+                        else:
+                            new_width = pil_img.width
+                            new_height = int(pil_img.width / new_aspect_ratio)
+
+                        resized = ImageOps.pad(pil_img, (new_width, new_height))
+                        (
+                            self.crop_img_size[0],
+                            self.crop_img_size[1],
+                        ) = await self.async_map_coordinates_offset(
+                            wsf, hsf, new_width, new_height
+                        )
+                        _LOGGER.debug(
+                            f"{self.file_name}: Image Aspect Ratio ({wsf}, {hsf}): {new_width}x{new_height}"
+                        )
+                        _LOGGER.debug(f"{self.file_name}: Frame Completed.")
+                        return resized
+                    else:
+                        _LOGGER.debug(f"{self.file_name}: Frame Completed.")
+                        return ImageOps.pad(pil_img, (width, height))
+                else:
+                    _LOGGER.debug(f"{self.file_name}: Frame Completed.")
+                    return pil_img
+        except (RuntimeError, RuntimeWarning) as e:
+            _LOGGER.warning(
+                f"{self.file_name}: Error {e} during image creation.",
+                exc_info=True,
+            )
+            return None
+
+    def get_frame_number(self) -> int:
+        """Return the frame number."""
+        return self.frame_number
+
+    def get_robot_position(self) -> any:
+        """Return the robot position."""
+        return self.robot_pos
+
+    def get_charger_position(self) -> any:
+        """Return the charger position."""
+        return self.charger_pos
+
+    def get_img_size(self) -> any:
+        """Return the image size."""
+        return self.img_size
+
+    def get_json_id(self) -> str:
+        """Return the json id."""
+        return self.json_id
+
+    async def get_rooms_attributes(
+        self, destinations: JsonType = None
+    ) -> RoomsProperties:
+        """Return the rooms attributes."""
+        if self.room_propriety:
+            return self.room_propriety
+        if self.json_data and destinations:
+            _LOGGER.debug("Checking for rooms data..")
+            self.room_propriety = await self.extract_room_properties(
+                self.json_data, destinations
+            )
+            if self.room_propriety:
+                _LOGGER.debug("Got Rooms Attributes.")
+        return self.room_propriety
+
+    async def async_get_robot_in_room(
+        self, robot_x: int, robot_y: int, angle: float
+    ) -> RobotPosition:
+        """Get the robot position and return in what room is."""
+
+        def _check_robot_position(x: int, y: int) -> bool:
+            x_in_room = (self.robot_in_room["left"] >= x) and (
+                self.robot_in_room["right"] <= x
+            )
+            y_in_room = (self.robot_in_room["up"] >= y) and (
+                self.robot_in_room["down"] <= y
+            )
+            return x_in_room and y_in_room
+
+        # Check if the robot coordinates are inside the room's
+        if self.robot_in_room and _check_robot_position(robot_x, robot_y):
+            temp = {
+                "x": robot_x,
+                "y": robot_y,
+                "angle": angle,
+                "in_room": self.robot_in_room["room"],
+            }
+            self.active_zones = self.shared.rand256_active_zone
+            self.zooming = False
+            if self.active_zones and (
+                (self.robot_in_room["id"]) in range(len(self.active_zones))
+            ):  # issue #100 Index out of range
+                self.zooming = bool(self.active_zones[self.robot_in_room["id"]])
+            return temp
+        # else we need to search and use the async method
+        _LOGGER.debug(f"{self.file_name} changed room.. searching..")
+        room_count = -1
+        last_room = None
+        if self.rooms_pos:
+            if self.robot_in_room:
+                last_room = self.robot_in_room
+            for room in self.rooms_pos:
+                corners = room["corners"]
+                room_count += 1
+                self.robot_in_room = {
+                    "id": room_count,
+                    "left": corners[0][0],
+                    "right": corners[2][0],
+                    "up": corners[0][1],
+                    "down": corners[2][1],
+                    "room": room["name"],
+                }
+                # Check if the robot coordinates are inside the room's corners
+                if _check_robot_position(robot_x, robot_y):
+                    temp = {
+                        "x": robot_x,
+                        "y": robot_y,
+                        "angle": angle,
+                        "in_room": self.robot_in_room["room"],
+                    }
+                    _LOGGER.debug(
+                        f"{self.file_name} is in {self.robot_in_room['room']}"
+                    )
+                    del room, corners, robot_x, robot_y  # free memory.
+                    return temp
+            del room, corners  # free memory.
+            _LOGGER.debug(
+                f"{self.file_name}: Not located within Camera Rooms coordinates."
+            )
+            self.zooming = False
+            self.robot_in_room = last_room
+            temp = {
+                "x": robot_x,
+                "y": robot_y,
+                "angle": angle,
+                "in_room": self.robot_in_room["room"],
+            }
+            return temp
+
+    def get_calibration_data(self, rotation_angle: int = 0) -> any:
+        """Return the map calibration data."""
+        if not self.calibration_data:
+            self.calibration_data = []
+            _LOGGER.info(
+                f"{self.file_name}: Getting Calibrations points {self.crop_area}"
+            )
+
+            # Define the map points (fixed)
+            map_points = [
+                {"x": 0, "y": 0},  # Top-left corner 0
+                {"x": self.crop_img_size[0], "y": 0},  # Top-right corner 1
+                {
+                    "x": self.crop_img_size[0],
+                    "y": self.crop_img_size[1],
+                },  # Bottom-right corner 2
+                {"x": 0, "y": self.crop_img_size[1]},  # Bottom-left corner (optional) 3
+            ]
+
+            # Valetudo Re version need corrections of the coordinates and are implemented with *10
+            vacuum_points = self.imu.re_get_vacuum_points(rotation_angle)
+
+            # Create the calibration data for each point
+            for vacuum_point, map_point in zip(vacuum_points, map_points):
+                calibration_point = {"vacuum": vacuum_point, "map": map_point}
+                self.calibration_data.append(calibration_point)
+
+        return self.calibration_data
+
+    async def async_map_coordinates_offset(
+        self, wsf: int, hsf: int, width: int, height: int
+    ) -> tuple[int, int]:
+        """
+        Offset the coordinates to the map.
+        """
+
+        if wsf == 1 and hsf == 1:
+            self.imu.set_image_offset_ratio_1_1(width, height, rand256=True)
+        elif wsf == 2 and hsf == 1:
+            self.imu.set_image_offset_ratio_2_1(width, height, rand256=True)
+        elif wsf == 3 and hsf == 2:
+            self.imu.set_image_offset_ratio_3_2(width, height, rand256=True)
+        elif wsf == 5 and hsf == 4:
+            self.imu.set_image_offset_ratio_5_4(width, height, rand256=True)
+        elif wsf == 9 and hsf == 16:
+            self.imu.set_image_offset_ratio_9_16(width, height, rand256=True)
+        elif wsf == 16 and hsf == 9:
+            self.imu.set_image_offset_ratio_16_9(width, height, rand256=True)
+        return width, height

valetudo_map_parser/reimg_draw.py

@@ -0,0 +1,372 @@
+"""
+Image Draw Class for Valetudo Rand256 Image Handling.
+This class is used to simplify the ImageHandler class.
+Version: 2024.12.0
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+
+from .config.types import Color, JsonType, NumpyArray
+from .config.drawable import Drawable
+from map_data import ImageData
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ImageDraw:
+    """Class to handle the image creation."""
+
+    """It Draws each elements of the images, like the walls, zones, paths, etc."""
+
+    def __init__(self, image_handler):
+        self.img_h = image_handler
+        self.file_name = self.img_h.shared.file_name
+        self.data = ImageData
+        self.draw = Drawable
+        self.color_grey = (128, 128, 128, 255)
+
+    async def async_draw_go_to_flag(
+        self, np_array: NumpyArray, m_json: JsonType, color_go_to: Color
+    ) -> NumpyArray:
+        """Draw the goto target flag on the map."""
+        try:
+            go_to = self.data.get_rrm_goto_target(m_json)
+            if go_to:
+                np_array = await self.draw.go_to_flag(
+                    np_array,
+                    (go_to[0], go_to[1]),
+                    self.img_h.img_rotate,
+                    color_go_to,
+                )
+                predicted_path = self.data.get_rrm_goto_predicted_path(m_json)
+                if predicted_path:
+                    np_array = await self.draw.lines(
+                        np_array, predicted_path, 3, self.color_grey
+                    )
+                return np_array
+            else:
+                return np_array
+        except Exception as e:
+            _LOGGER.warning(
+                f"{self.file_name}: Error in extraction of go to. {e}", exc_info=True
+            )
+            return np_array
+
+    async def async_segment_data(
+        self, m_json, size_x, size_y, pos_top, pos_left
+    ) -> None:
+        """Get the segments data from the JSON data."""
+        try:
+            if not self.img_h.segment_data:
+                (
+                    self.img_h.segment_data,
+                    self.img_h.outlines,
+                ) = await self.data.async_get_rrm_segments(
+                    m_json, size_x, size_y, pos_top, pos_left, True
+                )
+        except ValueError as e:
+            self.img_h.segment_data = None
+            _LOGGER.info(f"{self.file_name}: No segments data found. {e}")
+
+    async def async_draw_base_layer(
+        self,
+        m_json,
+        size_x,
+        size_y,
+        color_wall,
+        color_zone_clean,
+        color_background,
+        pixel_size,
+    ):
+        """Draw the base layer of the map."""
+        pos_top, pos_left = self.data.get_rrm_image_position(m_json)
+        walls_data = self.data.get_rrm_walls(m_json)
+        floor_data = self.data.get_rrm_floor(m_json)
+
+        _LOGGER.info(self.file_name + ": Empty image with background color")
+        img_np_array = await self.draw.create_empty_image(
+            self.img_h.img_size["x"], self.img_h.img_size["y"], color_background
+        )
+        room_id = 0
+        if self.img_h.frame_number == 0:
+            _LOGGER.info(self.file_name + ": Overlapping Layers")
+
+            # checking if there are segments too (sorted pixels in the raw data).
+            await self.async_segment_data(m_json, size_x, size_y, pos_top, pos_left)
+
+            img_np_array = await self._draw_floor(
+                img_np_array, floor_data, size_x, size_y, pos_top, pos_left, pixel_size
+            )
+            room_id, img_np_array = await self._draw_segments(
+                img_np_array,
+                pixel_size,
+                self.img_h.segment_data,
+                color_wall,
+                color_zone_clean,
+            )
+            img_np_array = await self._draw_walls(
+                img_np_array,
+                walls_data,
+                size_x,
+                size_y,
+                pos_top,
+                pos_left,
+                pixel_size,
+                color_wall,
+            )
+        return room_id, img_np_array
+
+    async def _draw_floor(
+        self, img_np_array, floor_data, size_x, size_y, pos_top, pos_left, pixel_size
+    ):
+        """Draw the floor data onto the image."""
+        pixels = self.data.from_rrm_to_compressed_pixels(
+            floor_data,
+            image_width=size_x,
+            image_height=size_y,
+            image_top=pos_top,
+            image_left=pos_left,
+        )
+        if pixels:
+            room_color = self.img_h.shared.rooms_colors[0]  # Using initial room_id = 0
+            img_np_array = await self.draw.from_json_to_image(
+                img_np_array, pixels, pixel_size, room_color
+            )
+        return img_np_array
+
+    async def _draw_segments(
+        self, img_np_array, pixel_size, segment_data, color_wall, color_zone_clean
+    ):
+        """Draw the segments onto the image and update room_id."""
+
+        room_id = 0
+        rooms_list = [color_wall]
+        if not segment_data:
+            _LOGGER.info(f"{self.file_name}: No segments data found.")
+            return room_id, img_np_array
+
+        if segment_data:
+            _LOGGER.info(f"{self.file_name}: Drawing segments.")
+            for pixels in segment_data:
+                room_color = self.img_h.shared.rooms_colors[room_id]
+                rooms_list.append(room_color)
+                if (
+                    self.img_h.active_zones
+                    and len(self.img_h.active_zones) > room_id
+                    and self.img_h.active_zones[room_id] == 1
+                ):
+                    room_color = (
+                        ((2 * room_color[0]) + color_zone_clean[0]) // 3,
+                        ((2 * room_color[1]) + color_zone_clean[1]) // 3,
+                        ((2 * room_color[2]) + color_zone_clean[2]) // 3,
+                        ((2 * room_color[3]) + color_zone_clean[3]) // 3,
+                    )
+                img_np_array = await self.draw.from_json_to_image(
+                    img_np_array, pixels, pixel_size, room_color
+                )
+                room_id += 1
+                if room_id > 15:
+                    room_id = 0
+        return room_id, img_np_array
+
+    async def _draw_walls(
+        self,
+        img_np_array,
+        walls_data,
+        size_x,
+        size_y,
+        pos_top,
+        pos_left,
+        pixel_size,
+        color_wall,
+    ):
+        """Draw the walls onto the image."""
+        walls = self.data.from_rrm_to_compressed_pixels(
+            walls_data,
+            image_width=size_x,
+            image_height=size_y,
+            image_left=pos_left,
+            image_top=pos_top,
+        )
+        if walls:
+            img_np_array = await self.draw.from_json_to_image(
+                img_np_array, walls, pixel_size, color_wall
+            )
+        return img_np_array
+
+    async def async_draw_charger(
+        self,
+        np_array: NumpyArray,
+        m_json: JsonType,
+        color_charger: Color,
+    ) -> (NumpyArray, dict):
+        """Get the charger position from the entity data."""
+        try:
+            charger_pos = self.data.rrm_coordinates_to_valetudo(
+                self.data.get_rrm_charger_position(m_json)
+            )
+        except Exception as e:
+            _LOGGER.warning(f"{self.file_name}: No charger position found. {e}")
+        else:
+            _LOGGER.debug("charger position: %s", charger_pos)
+            if charger_pos:
+                charger_pos_dictionary = {
+                    "x": (charger_pos[0] * 10),
+                    "y": (charger_pos[1] * 10),
+                }
+
+                np_array = await self.draw.battery_charger(
+                    np_array, charger_pos[0], charger_pos[1], color_charger
+                )
+                return np_array, charger_pos_dictionary
+            else:
+                return np_array, {}
+
+    async def async_draw_zones(
+        self,
+        m_json: JsonType,
+        np_array: NumpyArray,
+        color_zone_clean: Color,
+    ) -> NumpyArray:
+        """Get the zone clean from the JSON data."""
+        try:
+            zone_clean = self.data.get_rrm_currently_cleaned_zones(m_json)
+        except (ValueError, KeyError):
+            zone_clean = None
+        else:
+            _LOGGER.info(f"{self.file_name}: Got zones.")
+        if zone_clean:
+            return await self.draw.zones(np_array, zone_clean, color_zone_clean)
+        else:
+            return np_array
+
+    async def async_draw_virtual_restrictions(
+        self, m_json: JsonType, np_array: NumpyArray, color_no_go: Color
+    ) -> NumpyArray:
+        """Get the virtual walls from the JSON data."""
+        try:
+            virtual_walls = self.data.get_rrm_virtual_walls(m_json)
+        except (ValueError, KeyError):
+            virtual_walls = None
+        else:
+            _LOGGER.info(f"{self.file_name}: Got virtual walls.")
+        if virtual_walls:
+            np_array = await self.draw.draw_virtual_walls(
+                np_array, virtual_walls, color_no_go
+            )
+        try:
+            no_go_area = self.data.get_rrm_forbidden_zones(m_json)
+        except KeyError:
+            no_go_area = None
+        if no_go_area:
+            np_array = await self.draw.zones(np_array, no_go_area, color_no_go)
+        return np_array
+
+    async def async_draw_path(
+        self,
+        np_array: NumpyArray,
+        m_json: JsonType,
+        color_move: Color,
+    ) -> NumpyArray:
+        """Get the paths from the JSON data."""
+        # Initialize the variables
+        path_pixel_formatted = None
+        # Extract the paths data from the JSON data.
+        try:
+            path_pixel = self.data.get_rrm_path(m_json)
+            path_pixel_formatted = self.data.sublist_join(
+                self.data.rrm_valetudo_path_array(path_pixel["points"]), 2
+            )
+        except KeyError as e:
+            _LOGGER.warning(f"{self.file_name}: Error extracting paths data: {str(e)}")
+        finally:
+            if path_pixel_formatted:
+                np_array = await self.draw.lines(
+                    np_array, path_pixel_formatted, 5, color_move
+                )
+        return np_array
+
+    async def async_get_entity_data(self, m_json: JsonType) -> dict or None:
+        """Get the entity data from the JSON data."""
+        try:
+            entity_dict = self.data.find_points_entities(m_json)
+        except (ValueError, KeyError):
+            entity_dict = None
+        else:
+            _LOGGER.info(f"{self.file_name}: Got the points in the json.")
+        return entity_dict
+
+    @staticmethod
+    async def async_copy_array(original_array: NumpyArray) -> NumpyArray:
+        """Copy the array."""
+        return NumpyArray.copy(original_array)
+
+    async def calculate_array_hash(self, layers: dict, active: list[int] = None) -> str:
+        """Calculate the hash of the image based on the layers and active segments walls."""
+        self.img_h.active_zones = active
+        if layers and active:
+            data_to_hash = {
+                "layers": len(layers["wall"][0]),
+                "active_segments": tuple(active),
+            }
+            data_json = json.dumps(data_to_hash, sort_keys=True)
+            hash_value = hashlib.sha256(data_json.encode()).hexdigest()
+        else:
+            hash_value = None
+        return hash_value
+
+    async def async_get_robot_position(self, m_json: JsonType) -> tuple | None:
+        """Get the robot position from the entity data."""
+        robot_pos = None
+        robot_position = None
+        angle = [0, 0]
+        try:
+            robot_pos_data = self.data.get_rrm_robot_position(m_json)
+            robot_pos = self.data.rrm_coordinates_to_valetudo(robot_pos_data)
+            angle = self.data.get_rrm_robot_angle(m_json)
+        except (ValueError, KeyError):
+            _LOGGER.warning(f"{self.file_name} No robot position found.")
+            return None, None, None
+        finally:
+            robot_position_angle = round(angle[0], 0)
+            if robot_pos and robot_position_angle:
+                robot_position = robot_pos
+                _LOGGER.debug(
+                    f"robot position: {robot_pos}, robot angle: {robot_position_angle}"
+                )
+                if self.img_h.rooms_pos is None:
+                    self.img_h.robot_pos = {
+                        "x": robot_position[0] * 10,
+                        "y": robot_position[1] * 10,
+                        "angle": robot_position_angle,
+                    }
+                else:
+                    self.img_h.robot_pos = await self.img_h.async_get_robot_in_room(
+                        (robot_position[0] * 10),
+                        (robot_position[1] * 10),
+                        robot_position_angle,
+                    )
+        return robot_pos, robot_position, robot_position_angle
+
+    async def async_draw_robot_on_map(
+        self,
+        np_array: NumpyArray,
+        robot_pos: tuple,
+        robot_angle: float,
+        color_robot: Color,
+    ) -> NumpyArray:
+        """Draw the robot on the map."""
+        if robot_pos and robot_angle:
+            np_array = await self.draw.robot(
+                layers=np_array,
+                x=robot_pos[0],
+                y=robot_pos[1],
+                angle=robot_angle,
+                fill=color_robot,
+                robot_state=self.img_h.shared.vacuum_state,
+            )
+        return np_array

{valetudo_map_parser-0.1.5.dist-info → valetudo_map_parser-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.5
+Version: 0.1.6
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 Author: Sandro Cantarella

{valetudo_map_parser-0.1.5.dist-info → valetudo_map_parser-0.1.6.dist-info}/RECORD

@@ -1,17 +1,20 @@
-valetudo_map_parser/__init__.py,sha256=hNe0CiutftU06x96gO0dAmTtYonHtDeQIiNyAeTDYNw,679
+valetudo_map_parser/__init__.py,sha256=9eWCgcSvmRe_MWEInCAjXkF9LspOuCWesjr4eUtsdA8,790
 valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
 valetudo_map_parser/config/auto_crop.py,sha256=vaDAVVn86agrlEjX-rjYZxDtAZ7P92rWqF1nSyT2kJA,11014
 valetudo_map_parser/config/colors.py,sha256=HlgROKagpV7FP9LTU1IvhTKTYjnlBw1ZDMKHVJSct8M,6514
 valetudo_map_parser/config/drawable.py,sha256=8Fp4yqyFbsGvNyCEynYCTpiohRZk_plUSSOyHpECvj8,20356
+valetudo_map_parser/config/rand25_parser.py,sha256=vkghj60Bdq22P3UnLCkKc77mqyJP524z2O9k8NvEi6M,15806
 valetudo_map_parser/config/shared.py,sha256=8xYBUfKY-tiPhXaT5ttIasnCWL3_RLawIZeTValQC64,9462
 valetudo_map_parser/config/types.py,sha256=bVSEDE0ihrc01jG4fZ1_hUVtoj6hdkbqShytZ6wJwJY,16163
 valetudo_map_parser/hypfer_draw.py,sha256=R8JVrqPPavhj8exCDJKk1QsXgsB12cjy4AIgFffyQec,15773
 valetudo_map_parser/hypfer_handler.py,sha256=MoCO4zVflFd0HSB4IRz1EOjJtlMfaagJS7A-OqJUNIU,18457
 valetudo_map_parser/images_utils.py,sha256=Ls5OnXXcojBTuUagj3_N4tY3nOe9aot7gl5hrPCXKss,15262
-valetudo_map_parser/map_data.py,sha256=-6etLFZXZikFEUeR2YhPLgXu7dv3YRY2e-u5Mx9ogqw,19498
+valetudo_map_parser/map_data.py,sha256=yt_osaewoYjcQPV1u6R_N801XmAH8EgR7mKrsbOcph0,19449
 valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser-0.1.5.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.5.dist-info/METADATA,sha256=hEskOQOPS_evCvVAWCJxBTQiDJzfSk5u0sFDUlQDxTg,1026
-valetudo_map_parser-0.1.5.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.5.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
-valetudo_map_parser-0.1.5.dist-info/RECORD,,
+valetudo_map_parser/rand25_handler.py,sha256=pwbMEa4ZLtS3hsja2lC2D0zpa76mKWQz4mQ5yBJ-sa0,19872
+valetudo_map_parser/reimg_draw.py,sha256=zs-HHncsFxV5kozMqZ4XCYRJx8anQ3K0I440RPt7ADI,13404
+valetudo_map_parser-0.1.6.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.6.dist-info/METADATA,sha256=ABBsZ58Yz7Pp0ZnlOU9oX9EexC23iBS-dHV7QTnXmpw,1026
+valetudo_map_parser-0.1.6.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.6.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+valetudo_map_parser-0.1.6.dist-info/RECORD,,