valetudo-map-parser 0.1.7__tar.gz → 0.1.9b0__tar.gz

{valetudo_map_parser-0.1.7 → valetudo_map_parser-0.1.9b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.7
+Version: 0.1.9b0
 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.7 → valetudo_map_parser-0.1.9b0}/SCR/valetudo_map_parser/__init__.py

@@ -1,5 +1,5 @@
 """Valetudo map parser.
-Version: 0.1.7"""
+Version: 0.1.8"""
 
 from .hypfer_handler import HypferMapImageHandler
 from .rand25_handler import ReImageHandler

{valetudo_map_parser-0.1.7 → valetudo_map_parser-0.1.9b0}/SCR/valetudo_map_parser/config/auto_crop.py

@@ -70,7 +70,7 @@ class AutoCrop:
             )
         return trimmed_width, trimmed_height
 
-    async def _async_auto_crop_data(self, tdata=None):
+    async def _async_auto_crop_data(self): #, tdata=None
         """Load the auto crop data from the Camera config."""
         # todo: implement this method but from config data
         # if not self.imh.auto_crop:

{valetudo_map_parser-0.1.7 → valetudo_map_parser-0.1.9b0}/SCR/valetudo_map_parser/config/rand25_parser.py

@@ -162,7 +162,7 @@ class RRMapParser:
                 )
                 if segment_type == 0:
                     continue
-                elif segment_type == 1 and pixels:
+                if segment_type == 1 and pixels:
                     parameters["pixels"]["walls"].append(i)
                 else:
                     s = (
@@ -257,7 +257,7 @@ class RRMapParser:
 
     @callback
     def parse_rrm_data(
-        self, map_buf: bytes, pixels: bool = False
+            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"):
@@ -266,6 +266,18 @@ class RRMapParser:
         parsed_map_data = {}
         blocks = self.parse_block(map_buf, 0x14, None, pixels)
 
+        self._parse_image_data(parsed_map_data, blocks)
+        self._parse_charger_data(parsed_map_data, blocks)
+        self._parse_robot_data(parsed_map_data, blocks)
+        self._parse_zones_data(parsed_map_data, blocks)
+        self._parse_virtual_walls_data(parsed_map_data, blocks)
+        self._parse_misc_data(parsed_map_data, blocks)
+
+        return parsed_map_data
+
+    @staticmethod
+    def _parse_image_data(parsed_map_data: Dict[str, Any], blocks: Dict[int, Any]):
+        """Parse image-related data."""
         if RRMapParser.Types.IMAGE.value in blocks:
             parsed_map_data["image"] = blocks[RRMapParser.Types.IMAGE.value]
             for item in [
@@ -290,28 +302,27 @@ class RRMapParser:
                                 - parsed_map_data[item["path"]]["points"][-2][0],
                             )
                         )
+
+    @staticmethod
+    def _parse_charger_data(parsed_map_data: Dict[str, Any], blocks: Dict[int, Any]):
+        """Parse charger location data."""
         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
 
+    @staticmethod
+    def _parse_robot_data(parsed_map_data: Dict[str, Any], blocks: Dict[int, Any]):
+        """Parse robot position data."""
         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
-
+    @staticmethod
+    def _parse_zones_data(parsed_map_data: Dict[str, Any], blocks: Dict[int, Any]):
+        """Parse zones and forbidden zones data."""
         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],
@@ -319,13 +330,10 @@ class RRMapParser:
                     zone[2],
                     RRMapParser.Tools.DIMENSION_MM - zone[3],
                 ]
-                for zone in parsed_map_data["currently_cleaned_zones"]
+                for zone in blocks[RRMapParser.Types.CURRENTLY_CLEANED_ZONES.value]
             ]
 
         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],
@@ -337,13 +345,15 @@ class RRMapParser:
                     zone[6],
                     RRMapParser.Tools.DIMENSION_MM - zone[7],
                 ]
-                for zone in parsed_map_data["forbidden_zones"]
+                for zone in blocks[RRMapParser.Types.FORBIDDEN_ZONES.value]
             ]
 
+    @staticmethod
+    def _parse_virtual_walls_data(
+            parsed_map_data: Dict[str, Any], blocks: Dict[int, Any]
+    ):
+        """Parse virtual walls data."""
         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],
@@ -351,18 +361,18 @@ class RRMapParser:
                     wall[2],
                     RRMapParser.Tools.DIMENSION_MM - wall[3],
                 ]
-                for wall in parsed_map_data["virtual_walls"]
+                for wall in blocks[RRMapParser.Types.VIRTUAL_WALLS.value]
             ]
 
+    @staticmethod
+    def _parse_misc_data(parsed_map_data: Dict[str, Any], blocks: Dict[int, Any]):
+        """Parse miscellaneous data like cleaned blocks and mop zones."""
         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],
@@ -374,11 +384,9 @@ class RRMapParser:
                     zone[6],
                     RRMapParser.Tools.DIMENSION_MM - zone[7],
                 ]
-                for zone in parsed_map_data["forbidden_mop_zones"]
+                for zone in blocks[RRMapParser.Types.FORBIDDEN_MOP_ZONES.value]
             ]
 
-        return parsed_map_data
-
     def parse_data(
         self, payload: Optional[bytes] = None, pixels: bool = False
     ) -> Optional[Dict[str, Any]]:

{valetudo_map_parser-0.1.7 → valetudo_map_parser-0.1.9b0}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -2,7 +2,7 @@
 Hypfer Image Handler Class.
 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: 2024.08.0
+Version: 0.1.9
 """
 
 from __future__ import annotations

{valetudo_map_parser-0.1.7 → valetudo_map_parser-0.1.9b0}/SCR/valetudo_map_parser/map_data.py

@@ -209,10 +209,11 @@ class ImageData:
             max_y * pixel_size,
         )
 
-    # Added below in order to support Valetudo Re.
-    # This functions read directly the data from the json created
-    # from the parser for Valetudo Re. They allow to use the
-    # functions to draw the image without changes on the drawing class.
+
+class RandImageData:
+    """This functions read directly the data from the json created
+    from the parser for Valetudo Re. They allow to use the
+    functions to draw the image without changes on the drawing class."""
 
     @staticmethod
     def from_rrm_to_compressed_pixels(
@@ -297,7 +298,7 @@ class ImageData:
         except KeyError:
             return None
         predicted_path = ImageData.sublist_join(
-            ImageData.rrm_valetudo_path_array(points), 2
+            RandImageData.rrm_valetudo_path_array(points), 2
         )
         return predicted_path
 
@@ -330,7 +331,7 @@ class ImageData:
             return None
 
         if path_data and path_data != []:
-            path_data = ImageData.rrm_coordinates_to_valetudo(path_data)
+            path_data = RandImageData.rrm_coordinates_to_valetudo(path_data)
             return path_data
         return None
 
@@ -338,14 +339,14 @@ class ImageData:
     def get_rrm_currently_cleaned_zones(json_data: JsonType) -> dict:
         """Get the currently cleaned zones from the json."""
         re_zones = json_data.get("currently_cleaned_zones", [])
-        formatted_zones = ImageData.rrm_valetudo_format_zone(re_zones)
+        formatted_zones = RandImageData.rrm_valetudo_format_zone(re_zones)
         return formatted_zones
 
     @staticmethod
     def get_rrm_forbidden_zones(json_data: JsonType) -> dict:
         """Get the forbidden zones from the json."""
         re_zones = json_data.get("forbidden_zones", [])
-        formatted_zones = ImageData.rrm_valetudo_format_zone(re_zones)
+        formatted_zones = RandImageData.rrm_valetudo_format_zone(re_zones)
         return formatted_zones
 
     @staticmethod
@@ -406,7 +407,7 @@ class ImageData:
             tmp_data = json_data.get("virtual_walls", [])
         except KeyError:
             return None
-        virtual_walls = ImageData.rrm_valetudo_lines(tmp_data)
+        virtual_walls = RandImageData.rrm_valetudo_lines(tmp_data)
         return virtual_walls
 
     @staticmethod
@@ -424,7 +425,7 @@ class ImageData:
         """Get the image size from the json."""
         if isinstance(json_data, tuple):
             return 0, 0
-        image = ImageData.get_rrm_image(json_data)
+        image = RandImageData.get_rrm_image(json_data)
         if image == {}:
             return 0, 0
         dimensions = image.get("dimensions", {})
@@ -433,20 +434,20 @@ class ImageData:
     @staticmethod
     def get_rrm_image_position(json_data: JsonType) -> tuple:
         """Get the image position from the json."""
-        image = ImageData.get_rrm_image(json_data)
+        image = RandImageData.get_rrm_image(json_data)
         position = image.get("position", {})
         return position.get("top", 0), position.get("left", 0)
 
     @staticmethod
     def get_rrm_floor(json_data: JsonType) -> list:
         """Get the floor data from the json."""
-        img = ImageData.get_rrm_image(json_data)
+        img = RandImageData.get_rrm_image(json_data)
         return img.get("pixels", {}).get("floor", [])
 
     @staticmethod
     def get_rrm_walls(json_data: JsonType) -> list:
         """Get the walls data from the json."""
-        img = ImageData.get_rrm_image(json_data)
+        img = RandImageData.get_rrm_image(json_data)
         return img.get("pixels", {}).get("walls", [])
 
     @staticmethod
@@ -460,7 +461,7 @@ class ImageData:
     ) -> tuple or list:
         """Get the segments data from the json."""
 
-        img = ImageData.get_rrm_image(json_data)
+        img = RandImageData.get_rrm_image(json_data)
         seg_data = img.get("segments", {})
         seg_ids = seg_data.get("id")
         segments = []
@@ -469,7 +470,7 @@ class ImageData:
         for id_seg in seg_ids:
             tmp_data = seg_data.get("pixels_seg_" + str(id_seg))
             segments.append(
-                ImageData.from_rrm_to_compressed_pixels(
+                RandImageData.from_rrm_to_compressed_pixels(
                     tmp_data,
                     image_width=size_x,
                     image_height=size_y,
@@ -493,7 +494,7 @@ class ImageData:
     def get_rrm_segments_ids(json_data: JsonType) -> list or None:
         """Get the segments ids from the json."""
         try:
-            img = ImageData.get_rrm_image(json_data)
+            img = RandImageData.get_rrm_image(json_data)
             seg_ids = img.get("segments", {}).get("id", [])
         except KeyError:
             return None

{valetudo_map_parser-0.1.7 → valetudo_map_parser-0.1.9b0}/SCR/valetudo_map_parser/rand25_handler.py

@@ -2,7 +2,7 @@
 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
+Version: 0.1.9
 """
 
 from __future__ import annotations
@@ -11,19 +11,19 @@ import logging
 import uuid
 
 from PIL import Image, ImageOps
-
+from typing import Any
 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 .map_data import RandImageData
 from .reimg_draw import ImageDraw
 
 _LOGGER = logging.getLogger(__name__)
 
 
 # noinspection PyTypeChecker
-class ReImageHandler(object):
+class ReImageHandler:
     """
     Image Handler for Valetudo Re Vacuums.
     """
@@ -35,8 +35,8 @@ class ReImageHandler(object):
         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.crop_img_size = []  # Crop image size
+        self.data = RandImageData  # Image Data
         self.frame_number = 0  # Image Frame number
         self.max_frames = 1024
         self.go_to = None  # Go to position data
@@ -72,15 +72,15 @@ class ReImageHandler(object):
         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)
+        unsorted_id = RandImageData.get_rrm_segments_ids(json_data)
+        size_x, size_y = RandImageData.get_rrm_image_size(json_data)
+        top, left = RandImageData.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(
+                ) = await RandImageData.async_get_rrm_segments(
                     json_data, size_x, size_y, top, left, True
                 )
             dest_json = destinations
@@ -126,23 +126,23 @@ class ReImageHandler(object):
                 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!")
+                if room_properties or zone_properties:
+                    extracted_data = [
+                        f"{len(room_properties)} Rooms" if room_properties else None,
+                        f"{len(zone_properties)} Zones" if zone_properties else None,
+                    ]
+                    extracted_data = ", ".join(filter(None, extracted_data))
+                    _LOGGER.debug("Extracted data: %s", extracted_data)
                 else:
                     self.rooms_pos = None
                     _LOGGER.debug(
-                        f"{self.file_name}: Rooms and Zones data not available!"
+                        "%s: Rooms and Zones data not available!", self.file_name
                     )
                 return room_properties, zone_properties, point_properties
-        except Exception as e:
+        except RuntimeError as e:
             _LOGGER.debug(
-                f"No rooms Data or Error in extract_room_properties: {e}",
+                "No rooms Data or Error in extract_room_properties: %s",
+                e,
                 exc_info=True,
             )
             return None, None, None
@@ -160,154 +160,164 @@ class ReImageHandler(object):
 
         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
+                _LOGGER.info("%s: Composing the image for the camera.", self.file_name)
                 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
+                _LOGGER.info("Vacuum Data ID: %s", self.json_id)
+
                 (
-                    robot_pos,
+                    img_np_array,
                     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.
+                ) = await self._setup_robot_and_image(
+                    m_json, size_x, size_y, colors, destinations
+                )
+
+                # Increment frame number
                 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)}"
+                    "%s: Frame number %s", self.file_name, str(self.frame_number)
                 )
-                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,
+                if self.frame_number > 5:
+                    self.frame_number = 0
+
+                # Draw map elements
+                img_np_array = await self._draw_map_elements(
+                    img_np_array, m_json, colors, robot_position, robot_position_angle
                 )
+
+                # Final adjustments
                 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
+
+                return await self._finalize_image(pil_img)
+
         except (RuntimeError, RuntimeWarning) as e:
             _LOGGER.warning(
-                f"{self.file_name}: Error {e} during image creation.",
+                "%s: Runtime Error %s during image creation.",
+                self.file_name,
+                str(e),
                 exc_info=True,
             )
             return None
 
+    async def _setup_robot_and_image(
+        self, m_json, size_x, size_y, colors, destinations
+    ):
+        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("%s: Completed base Layers", self.file_name)
+            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)
+        return self.img_base_layer, robot_position, robot_position_angle
+
+    async def _draw_map_elements(
+        self, img_np_array, m_json, colors, robot_position, robot_position_angle
+    ):
+        img_np_array, self.charger_pos = await self.imd.async_draw_charger(
+            img_np_array, m_json, colors["charger"]
+        )
+        img_np_array = await self.imd.async_draw_zones(
+            m_json, img_np_array, colors["zone_clean"]
+        )
+        img_np_array = await self.imd.async_draw_virtual_restrictions(
+            m_json, img_np_array, colors["no_go"]
+        )
+        img_np_array = await self.imd.async_draw_path(
+            img_np_array, m_json, colors["move"]
+        )
+        await self.imd.async_draw_go_to_flag(img_np_array, m_json, colors["go_to"])
+        img_np_array = await self.imd.async_draw_robot_on_map(
+            img_np_array, robot_position, robot_position_angle, colors["robot"]
+        )
+        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,
+        )
+        return img_np_array
+
+    async def _finalize_image(self, pil_img):
+        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("Aspect Ratio: %s, %s", str(wsf), str(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(
+                    "%s: Image Aspect Ratio: %s, %s",
+                    self.file_name,
+                    str(wsf),
+                    str(hsf),
+                )
+                _LOGGER.debug("%s: Resized Frame Completed.", self.file_name)
+                return resized
+            _LOGGER.debug("%s: Padded Frame Completed.", self.file_name)
+            return ImageOps.pad(pil_img, (width, height))
+        _LOGGER.debug("%s: Frame Completed.", self.file_name)
+        return pil_img
+
     def get_frame_number(self) -> int:
         """Return the frame number."""
         return self.frame_number
 
-    def get_robot_position(self) -> any:
+    def get_robot_position(self) -> Any:
         """Return the robot position."""
         return self.robot_pos
 
-    def get_charger_position(self) -> any:
+    def get_charger_position(self) -> Any:
         """Return the charger position."""
         return self.charger_pos
 
-    def get_img_size(self) -> any:
+    def get_img_size(self) -> Any:
         """Return the image size."""
         return self.img_size
 
@@ -336,15 +346,13 @@ class ReImageHandler(object):
         """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
+            # Check if the robot coordinates are inside the room's corners
+            return (
+                self.robot_in_room["left"] >= x >= self.robot_in_room["right"]
+                and self.robot_in_room["up"] >= y >= self.robot_in_room["down"]
             )
-            return x_in_room and y_in_room
 
-        # Check if the robot coordinates are inside the room's
+        # 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,
@@ -360,7 +368,7 @@ class ReImageHandler(object):
                 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..")
+        _LOGGER.debug("%s Changed room.. searching..", self.file_name)
         room_count = -1
         last_room = None
         if self.rooms_pos:
@@ -386,13 +394,13 @@ class ReImageHandler(object):
                         "in_room": self.robot_in_room["room"],
                     }
                     _LOGGER.debug(
-                        f"{self.file_name} is in {self.robot_in_room['room']}"
+                        "%s is in %s", self.file_name, 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."
+                "%s: Not located within Camera Rooms coordinates.", self.file_name
             )
             self.zooming = False
             self.robot_in_room = last_room
@@ -404,12 +412,14 @@ class ReImageHandler(object):
             }
             return temp
 
-    def get_calibration_data(self, rotation_angle: int = 0) -> any:
+    def get_calibration_data(self, rotation_angle: int = 0) -> Any:
         """Return the map calibration data."""
-        if not self.calibration_data:
+        if not self.calibration_data and self.crop_img_size:
             self.calibration_data = []
             _LOGGER.info(
-                f"{self.file_name}: Getting Calibrations points {self.crop_area}"
+                "%s: Getting Calibrations points %s",
+                self.file_name,
+                str(self.crop_area),
             )
 
             # Define the map points (fixed)

{valetudo_map_parser-0.1.7 → valetudo_map_parser-0.1.9b0}/SCR/valetudo_map_parser/reimg_draw.py

@@ -12,7 +12,8 @@ import logging
 
 from .config.types import Color, JsonType, NumpyArray
 from .config.drawable import Drawable
-from map_data import ImageData
+from .map_data import RandImageData
+from .map_data import ImageData
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -20,12 +21,11 @@ _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.data = RandImageData
+        self.data_sup = ImageData
         self.draw = Drawable
         self.color_grey = (128, 128, 128, 255)
 
@@ -47,12 +47,13 @@ class ImageDraw:
                     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:
+            return np_array
+        except KeyError as e:
             _LOGGER.warning(
-                f"{self.file_name}: Error in extraction of go to. {e}", exc_info=True
+                "%s: Error in extraction of go-to target: %s",
+                self.file_name,
+                e,
+                exc_info=True,
             )
             return np_array
 
@@ -70,7 +71,7 @@ class ImageDraw:
                 )
         except ValueError as e:
             self.img_h.segment_data = None
-            _LOGGER.info(f"{self.file_name}: No segments data found. {e}")
+            _LOGGER.info("%s: No segments data found: %s", self.file_name, e)
 
     async def async_draw_base_layer(
         self,
@@ -87,13 +88,13 @@ class ImageDraw:
         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")
+        _LOGGER.info("%s: Empty image with background color", self.file_name)
         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")
+            _LOGGER.info("%s: Overlapping Layers", self.file_name)
 
             # 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)
@@ -146,31 +147,30 @@ class ImageDraw:
         room_id = 0
         rooms_list = [color_wall]
         if not segment_data:
-            _LOGGER.info(f"{self.file_name}: No segments data found.")
+            _LOGGER.info("%s: No segments data found.", self.file_name)
             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
+        _LOGGER.info("%s: Drawing segments.", self.file_name)
+        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,
                 )
-                room_id += 1
-                if room_id > 15:
-                    room_id = 0
+            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(
@@ -209,10 +209,10 @@ class ImageDraw:
             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}")
+        except KeyError as e:
+            _LOGGER.warning("%s: No charger position found: %s", self.file_name, e)
         else:
-            _LOGGER.debug("charger position: %s", charger_pos)
+            _LOGGER.debug("Charger position: %s", charger_pos)
             if charger_pos:
                 charger_pos_dictionary = {
                     "x": (charger_pos[0] * 10),
@@ -223,8 +223,7 @@ class ImageDraw:
                     np_array, charger_pos[0], charger_pos[1], color_charger
                 )
                 return np_array, charger_pos_dictionary
-            else:
-                return np_array, {}
+        return np_array, {}
 
     async def async_draw_zones(
         self,
@@ -237,12 +236,11 @@ class ImageDraw:
             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:
+            _LOGGER.info("%s: Got zones.", self.file_name)
             return await self.draw.zones(np_array, zone_clean, color_zone_clean)
-        else:
-            return np_array
+        return np_array
 
     async def async_draw_virtual_restrictions(
         self, m_json: JsonType, np_array: NumpyArray, color_no_go: Color
@@ -252,9 +250,9 @@ class ImageDraw:
             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:
+            _LOGGER.info("%s: Got virtual walls.", self.file_name)
             np_array = await self.draw.draw_virtual_walls(
                 np_array, virtual_walls, color_no_go
             )
@@ -278,11 +276,13 @@ class ImageDraw:
         # 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(
+            path_pixel_formatted = self.data_sup.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)}")
+            _LOGGER.warning(
+                "%s: Error extracting paths data: %s", self.file_name, str(e)
+            )
         finally:
             if path_pixel_formatted:
                 np_array = await self.draw.lines(
@@ -293,11 +293,11 @@ class ImageDraw:
     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)
+            entity_dict = self.data_sup.find_points_entities(m_json)
         except (ValueError, KeyError):
             entity_dict = None
         else:
-            _LOGGER.info(f"{self.file_name}: Got the points in the json.")
+            _LOGGER.info("%s: Got the points in the json.", self.file_name)
         return entity_dict
 
     @staticmethod
@@ -329,14 +329,16 @@ class ImageDraw:
             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.")
+            _LOGGER.warning("%s No robot position found.", self.file_name)
             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}"
+                    "robot position: %s, robot angle: %s",
+                    str(robot_pos),
+                    str(robot_position_angle),
                 )
                 if self.img_h.rooms_pos is None:
                     self.img_h.robot_pos = {

{valetudo_map_parser-0.1.7 → valetudo_map_parser-0.1.9b0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "valetudo-map-parser"
-version = "0.1.7"
+version = "0.1.9.b0"
 description = "A Python library to parse Valetudo map data returning a PIL Image object."
 authors = ["Sandro Cantarella <gsca075@gmail.com>"]
 license = "Apache-2.0"