valetudo-map-parser 0.1.9b3__tar.gz → 0.1.9b5__tar.gz

{valetudo_map_parser-0.1.9b3 → valetudo_map_parser-0.1.9b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b3
+Version: 0.1.9b5
 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.9b3 → valetudo_map_parser-0.1.9b5}/SCR/valetudo_map_parser/config/colors.py

@@ -2,9 +2,9 @@
 
 from __future__ import annotations
 
-from enum import StrEnum
-from typing import List, Dict, Tuple
 import logging
+from enum import StrEnum
+from typing import Dict, List, Tuple
 
 _LOGGER = logging.getLogger(__name__)
 

{valetudo_map_parser-0.1.9b3 → valetudo_map_parser-0.1.9b5}/SCR/valetudo_map_parser/config/rand25_parser.py

@@ -5,10 +5,10 @@ Version: v2024.08.2
 - 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
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional, TypeVar
 
 _CallableT = TypeVar("_CallableT", bound=Callable[..., Any])
 
@@ -387,6 +387,11 @@ class RRMapParser:
                 for zone in blocks[RRMapParser.Types.FORBIDDEN_MOP_ZONES.value]
             ]
 
+        if RRMapParser.Types.GOTO_TARGET.value in blocks:
+            parsed_map_data["goto_target"] = blocks[
+                RRMapParser.Types.GOTO_TARGET.value
+            ]["position"]
+
     def parse_data(
         self, payload: Optional[bytes] = None, pixels: bool = False
     ) -> Optional[Dict[str, Any]]:

{valetudo_map_parser-0.1.9b3 → valetudo_map_parser-0.1.9b5}/SCR/valetudo_map_parser/config/shared.py

@@ -9,7 +9,9 @@ import logging
 
 from .types import (
     ATTR_CALIBRATION_POINTS,
+    ATTR_CAMERA_MODE,
     ATTR_MARGINS,
+    ATTR_OBSTACLES,
     ATTR_POINTS,
     ATTR_ROOMS,
     ATTR_ROTATE,
@@ -19,8 +21,6 @@ from .types import (
     ATTR_VACUUM_POSITION,
     ATTR_VACUUM_STATUS,
     ATTR_ZONES,
-    ATTR_CAMERA_MODE,
-    ATTR_OBSTACLES,
     CONF_ASPECT_RATIO,
     CONF_AUTO_ZOOM,
     CONF_OFFSET_BOTTOM,
@@ -35,8 +35,8 @@ from .types import (
     CONF_ZOOM_LOCK_RATIO,
     DEFAULT_VALUES,
     CameraModes,
+    Colors,
 )
-from .types import Colors
 
 _LOGGER = logging.getLogger(__name__)
 

valetudo_map_parser-0.1.9b5/SCR/valetudo_map_parser/config/utils.py

@@ -0,0 +1,132 @@
+"""Utility code for the valetudo map parser."""
+
+import hashlib
+import json
+from logging import getLogger
+
+from PIL import ImageOps
+
+from ..images_utils import ImageUtils as ImUtils
+from .types import ChargerPosition, ImageSize, NumpyArray, RobotPosition
+
+_LOGGER = getLogger(__name__)
+
+
+class BaseHandler:
+    """Avoid Code duplication"""
+
+    def __init__(self):
+        self.file_name = None
+        self.img_size = None
+        self.json_data = None
+        self.json_id = None
+        self.path_pixels = None
+        self.robot_in_room = None
+        self.robot_pos = None
+        self.room_propriety = None
+        self.rooms_pos = None
+        self.charger_pos = None
+        self.frame_number = 0
+        self.max_frames = 1024
+        self.crop_img_size = [0, 0]
+        self.imu = ImUtils(self)  # Image Utils
+
+    def get_frame_number(self) -> int:
+        """Return the frame number of the image."""
+        return self.frame_number
+
+    def get_robot_position(self) -> RobotPosition | None:
+        """Return the robot position."""
+        return self.robot_pos
+
+    def get_charger_position(self) -> ChargerPosition | None:
+        """Return the charger position."""
+        return self.charger_pos
+
+    def get_img_size(self) -> ImageSize | None:
+        """Return the size of the image."""
+        return self.img_size
+
+    def get_json_id(self) -> str | None:
+        """Return the JSON ID from the image."""
+        return self.json_id
+
+    async def async_resize_image(
+        self, pil_img, width, height, aspect_ratio=None, is_rand=False
+    ):
+        """Resize the image to the given dimensions and aspect ratio."""
+        if aspect_ratio:
+            wsf, hsf = [int(x) for x in aspect_ratio.split(",")]
+            if wsf == 0 or hsf == 0:
+                return pil_img
+            new_aspect_ratio = wsf / hsf
+            if width / height > 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)
+                _LOGGER.debug(
+                    "%s: Image Aspect Ratio: %s, %s",
+                    self.file_name,
+                    str(wsf),
+                    str(hsf),
+                )
+                (
+                    self.crop_img_size[0],
+                    self.crop_img_size[1],
+                ) = await self.async_map_coordinates_offset(
+                    wsf, hsf, new_width, new_height, is_rand
+                )
+            return ImageOps.pad(pil_img, (new_width, new_height))
+        return ImageOps.pad(pil_img, (width, height))
+
+    async def async_map_coordinates_offset(
+        self, wsf: int, hsf: int, width: int, height: int, rand256: bool = False
+    ) -> 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)
+        elif wsf == 2 and hsf == 1:
+            self.imu.set_image_offset_ratio_2_1(width, height, rand256)
+        elif wsf == 3 and hsf == 2:
+            self.imu.set_image_offset_ratio_3_2(width, height, rand256)
+        elif wsf == 5 and hsf == 4:
+            self.imu.set_image_offset_ratio_5_4(width, height, rand256)
+        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
+
+    @staticmethod
+    async def calculate_array_hash(layers: dict, active: list[int] = None) -> str:
+        """Calculate the hash of the image based on layers and active zones."""
+        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)
+            return hashlib.sha256(data_json.encode()).hexdigest()
+        return None
+
+    @staticmethod
+    async def async_copy_array(original_array: NumpyArray) -> NumpyArray:
+        """Copy the array."""
+        return NumpyArray.copy(original_array)
+
+    def get_map_points(self) -> dict:
+        """Return the map points."""
+        return [
+            {"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_map_parser-0.1.9b3 → valetudo_map_parser-0.1.9b5}/SCR/valetudo_map_parser/hypfer_draw.py

@@ -6,16 +6,9 @@ Version: 2024.07.2
 
 from __future__ import annotations
 
-import hashlib
-import json
 import logging
 
-from .config.types import (
-    Color,
-    JsonType,
-    NumpyArray,
-    RobotPosition,
-)
+from .config.types import Color, JsonType, NumpyArray, RobotPosition
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -288,25 +281,6 @@ class ImageDraw:
             _LOGGER.info("%s: Got the points in the json.", self.file_name)
         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_in_room(
         self, robot_y: int = 0, robot_x: int = 0, angle: float = 0.0
     ) -> RobotPosition:

{valetudo_map_parser-0.1.9b3 → valetudo_map_parser-0.1.9b5}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -12,58 +12,35 @@ import logging
 
 from PIL import Image
 
-from .config.types import (
-    CalibrationPoints,
-    ChargerPosition,
-    ImageSize,
-    RobotPosition,
-    RoomsProperties,
-)
 from .config.auto_crop import AutoCrop
 from .config.drawable import Drawable
 from .config.shared import CameraShared
+from .config.types import COLORS, CalibrationPoints, Colors, RoomsProperties
+from .config.utils import BaseHandler
+from .hypfer_draw import ImageDraw as ImDraw
 from .map_data import ImageData
-from .images_utils import (
-    ImageUtils as ImUtils,
-    resize_to_aspect_ratio,
-)
-from .hypfer_draw import (
-    ImageDraw as ImDraw,
-)
-from .config.colors import ColorsManagment, SupportedColor
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class HypferMapImageHandler:
+class HypferMapImageHandler(BaseHandler):
     """Map Image Handler Class.
     This class is used to handle the image data and the drawing of the map."""
 
     def __init__(self, shared_data: CameraShared):
         """Initialize the Map Image Handler."""
+        super().__init__()
         self.shared = shared_data  # camera shared data
-        self.file_name = self.shared.file_name  # file name of the vacuum.
         self.auto_crop = None  # auto crop data to be calculate once.
         self.calibration_data = None  # camera shared data.
-        self.charger_pos = None  # vacuum data charger position.
         self.crop_area = None  # module shared for calibration data.
-        self.crop_img_size = None  # size of the image cropped calibration data.
         self.data = ImageData  # imported Image Data Module.
         self.draw = Drawable  # imported Drawing utilities
         self.go_to = None  # vacuum go to data
         self.img_hash = None  # hash of the image calculated to check differences.
         self.img_base_layer = None  # numpy array store the map base layer.
-        self.img_size = None  # size of the created image
-        self.json_data = None  # local stored and shared json data.
-        self.json_id = None  # grabbed data of the vacuum image id.
-        self.path_pixels = None  # vacuum path datas.
-        self.robot_in_room = None  # vacuum room position.
-        self.robot_pos = None  # vacuum coordinates.
-        self.room_propriety = None  # vacuum segments data.
-        self.rooms_pos = None  # vacuum room coordinates / name list.
         self.active_zones = None  # vacuum active zones.
         self.frame_number = 0  # frame number of the image.
-        self.max_frames = 1024
         self.zooming = False  # zooming the image.
         self.svg_wait = False  # SVG image creation wait.
         self.trim_down = 0  # memory stored trims calculated once.
@@ -77,11 +54,9 @@ class HypferMapImageHandler:
         self.offset_x = 0  # offset x for the aspect ratio.
         self.offset_y = 0  # offset y for the aspect ratio.
         self.imd = ImDraw(self)
-        self.imu = ImUtils(self)
         self.ac = AutoCrop(self)
-        self.colors_manager = ColorsManagment({})
-        self.rooms_colors = self.colors_manager.get_rooms_colors()
         self.color_grey = (128, 128, 128, 255)
+        self.file_name = self.shared.file_name  # file name of the vacuum.
 
     async def async_extract_room_properties(self, json_data) -> RoomsProperties:
         """Extract room properties from the JSON data."""
@@ -132,23 +107,6 @@ class HypferMapImageHandler:
             self.rooms_pos = None
         return room_properties
 
-    async def _async_initialize_colors(self):
-        """Initialize and return all required colors."""
-        return {
-            "color_wall": self.colors_manager.get_colour(SupportedColor.WALLS),
-            "color_no_go": self.colors_manager.get_colour(SupportedColor.NO_GO),
-            "color_go_to": self.colors_manager.get_colour(SupportedColor.GO_TO),
-            "color_robot": self.colors_manager.get_colour(SupportedColor.ROBOT),
-            "color_charger": self.colors_manager.get_colour(SupportedColor.CHARGER),
-            "color_move": self.colors_manager.get_colour(SupportedColor.PATH),
-            "color_background": self.colors_manager.get_colour(
-                SupportedColor.MAP_BACKGROUND
-            ),
-            "color_zone_clean": self.colors_manager.get_colour(
-                SupportedColor.ZONE_CLEAN
-            ),
-        }
-
     # noinspection PyUnresolvedReferences,PyUnboundLocalVariable
     async def async_get_image_from_json(
         self,
@@ -161,7 +119,9 @@ class HypferMapImageHandler:
         @return Image.Image: The image to display.
         """
         # Initialize the colors.
-        colors = await self._async_initialize_colors()
+        colors: Colors = {
+            name: self.shared.user_colors[idx] for idx, name in enumerate(COLORS)
+        }
         # Check if the JSON data is not None else process the image.
         try:
             if m_json is not None:
@@ -190,12 +150,12 @@ class HypferMapImageHandler:
                 # Get the pixels size and layers from the JSON data
                 pixel_size = int(m_json["pixelSize"])
                 layers, active = self.data.find_layers(m_json["layers"], {}, [])
-                new_frame_hash = await self.imd.calculate_array_hash(layers, active)
+                new_frame_hash = await self.calculate_array_hash(layers, active)
                 if self.frame_number == 0:
                     self.img_hash = new_frame_hash
                     # empty image
                     img_np_array = await self.draw.create_empty_image(
-                        size_x, size_y, colors["color_background"]
+                        size_x, size_y, colors["background"]
                     )
                     # overlapping layers and segments
                     for layer_type, compressed_pixels_list in layers.items():
@@ -203,21 +163,21 @@ class HypferMapImageHandler:
                             img_np_array,
                             compressed_pixels_list,
                             layer_type,
-                            colors["color_wall"],
-                            colors["color_zone_clean"],
+                            colors["wall"],
+                            colors["zone_clean"],
                             pixel_size,
                         )
                     # Draw the virtual walls if any.
                     img_np_array = await self.imd.async_draw_virtual_walls(
-                        m_json, img_np_array, colors["color_no_go"]
+                        m_json, img_np_array, colors["no_go"]
                     )
                     # Draw charger.
                     img_np_array = await self.imd.async_draw_charger(
-                        img_np_array, entity_dict, colors["color_charger"]
+                        img_np_array, entity_dict, colors["charger"]
                     )
                     # Draw obstacles if any.
                     img_np_array = await self.imd.async_draw_obstacle(
-                        img_np_array, entity_dict, colors["color_no_go"]
+                        img_np_array, entity_dict, colors["no_go"]
                     )
                     # Robot and rooms position
                     if (room_id > 0) and not self.room_propriety:
@@ -232,7 +192,7 @@ class HypferMapImageHandler:
                             )
                     _LOGGER.info("%s: Completed base Layers", self.file_name)
                     # Copy the new array in base layer.
-                    self.img_base_layer = await self.imd.async_copy_array(img_np_array)
+                    self.img_base_layer = await self.async_copy_array(img_np_array)
                 self.shared.frame_number = self.frame_number
                 self.frame_number += 1
                 if (self.frame_number >= self.max_frames) or (
@@ -246,18 +206,18 @@ class HypferMapImageHandler:
                     str(self.frame_number),
                 )
                 # Copy the base layer to the new image.
-                img_np_array = await self.imd.async_copy_array(self.img_base_layer)
+                img_np_array = await self.async_copy_array(self.img_base_layer)
                 # All below will be drawn at each frame.
                 # Draw zones if any.
-                img_np_array = await self.imd.async_draw_zones(
+                img_np_array = await self.async_draw_zones(
                     m_json,
                     img_np_array,
-                    colors["color_zone_clean"],
-                    colors["color_no_go"],
+                    colors["zone_clean"],
+                    colors["no_go"],
                 )
                 # Draw the go_to target flag.
                 img_np_array = await self.imd.draw_go_to_flag(
-                    img_np_array, entity_dict, colors["color_go_to"]
+                    img_np_array, entity_dict, colors["go_to"]
                 )
                 # Draw path prediction and paths.
                 img_np_array = await self.imd.async_draw_paths(
@@ -304,15 +264,8 @@ class HypferMapImageHandler:
             ):
                 width = self.shared.image_ref_width
                 height = self.shared.image_ref_height
-                (
-                    resized_image,
-                    self.crop_img_size,
-                ) = await resize_to_aspect_ratio(
-                    pil_img,
-                    width,
-                    height,
-                    self.shared.image_aspect_ratio,
-                    self.async_map_coordinates_offset,
+                resized_image = await self.async_resize_image(
+                    pil_img, width, height, self.shared.image_aspect_ratio
                 )
                 return resized_image
             _LOGGER.debug("%s: Frame Completed.", self.file_name)
@@ -326,26 +279,6 @@ class HypferMapImageHandler:
             )
             return None
 
-    def get_frame_number(self) -> int:
-        """Return the frame number of the image."""
-        return self.frame_number
-
-    def get_robot_position(self) -> RobotPosition | None:
-        """Return the robot position."""
-        return self.robot_pos
-
-    def get_charger_position(self) -> ChargerPosition | None:
-        """Return the charger position."""
-        return self.charger_pos
-
-    def get_img_size(self) -> ImageSize | None:
-        """Return the size of the image."""
-        return self.img_size
-
-    def get_json_id(self) -> str | None:
-        """Return the JSON ID from the image."""
-        return self.json_id
-
     async def async_get_rooms_attributes(self) -> RoomsProperties:
         """Get the rooms attributes from the JSON data.
         :return: The rooms attribute's."""
@@ -368,15 +301,7 @@ class HypferMapImageHandler:
         _LOGGER.info("Getting %s Calibrations points.", self.file_name)
 
         # 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
-        ]
+        map_points = self.get_map_points()
         # Calculate the calibration points in the vacuum coordinate system
         vacuum_points = self.imu.get_vacuum_points(rotation_angle)
 
@@ -386,33 +311,3 @@ class HypferMapImageHandler:
             calibration_data.append(calibration_point)
         del vacuum_points, map_points, calibration_point, rotation_angle  # free memory.
         return 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.
-        :param wsf: Width scale factor.
-        :param hsf: Height scale factor.
-        :param width: Width of the image.
-        :param height: Height of the image.
-        :return: A tuple containing the adjusted (width, height) values
-        :raises ValueError: If any input parameters are negative
-        """
-
-        if any(x < 0 for x in (wsf, hsf, width, height)):
-            raise ValueError("All parameters must be positive integers")
-
-        if wsf == 1 and hsf == 1:
-            self.imu.set_image_offset_ratio_1_1(width, height)
-        elif wsf == 2 and hsf == 1:
-            self.imu.set_image_offset_ratio_2_1(width, height)
-        elif wsf == 3 and hsf == 2:
-            self.imu.set_image_offset_ratio_3_2(width, height)
-        elif wsf == 5 and hsf == 4:
-            self.imu.set_image_offset_ratio_5_4(width, height)
-        elif wsf == 9 and hsf == 16:
-            self.imu.set_image_offset_ratio_9_16(width, height)
-        elif wsf == 16 and hsf == 9:
-            self.imu.set_image_offset_ratio_16_9(width, height)
-        return width, height

{valetudo_map_parser-0.1.9b3 → valetudo_map_parser-0.1.9b5}/SCR/valetudo_map_parser/images_utils.py

@@ -8,8 +8,6 @@ from __future__ import annotations
 
 import logging
 
-from PIL import Image, ImageOps
-
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -295,7 +293,7 @@ class ImageUtils:
         )
 
     async def async_zone_propriety(self, zones_data) -> dict:
-        """Get the zone propiety"""
+        """Get the zone propriety"""
         zone_properties = {}
         id_count = 1
         for zone in zones_data:
@@ -316,7 +314,7 @@ class ImageUtils:
         return zone_properties
 
     async def async_points_propriety(self, points_data) -> dict:
-        """Get the point propiety"""
+        """Get the point propriety"""
         point_properties = {}
         id_count = 1
         for point in points_data:
@@ -335,64 +333,3 @@ class ImageUtils:
             if id_count > 1:
                 _LOGGER.debug("%s: Point Properties updated.", self.file_name)
         return point_properties
-
-
-async def resize_to_aspect_ratio(
-    pil_img: Image.Image,
-    ref_width: int,
-    ref_height: int,
-    aspect_ratio: str = "None",
-    async_map_coordinates_offset=None,
-) -> tuple:
-    """
-    Resize the image to match the given aspect ratio, maintaining the camera's aspect ratio.
-
-    Args:
-        pil_img (PIL.Image): The input image to resize.
-        ref_width (int): The reference width for the image.
-        ref_height (int): The reference height for the image.
-        aspect_ratio (str): Aspect ratio in the format "width,height" or "None" for default.
-        async_map_coordinates_offset (callable): Async function to compute coordinate offsets.
-
-    Returns:
-        tuple: A resized image and crop image size as a tuple (PIL.Image, list).
-    """
-    crop_img_size = [0, 0]
-
-    if aspect_ratio and aspect_ratio != "None":
-        try:
-            # Parse aspect ratio (e.g., "16,9")
-            wsf, hsf = [int(x) for x in aspect_ratio.split(",")]
-            new_aspect_ratio = wsf / hsf
-
-            # Calculate current aspect ratio
-            current_aspect_ratio = ref_width / ref_height
-
-            # Resize based on aspect ratio comparison
-            if current_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)
-
-            # Resize image using padding
-            resized_img = ImageOps.pad(pil_img, (new_width, new_height))
-
-            # Compute crop image size if mapping offset function is provided
-            if async_map_coordinates_offset:
-                (
-                    crop_img_size[0],
-                    crop_img_size[1],
-                ) = await async_map_coordinates_offset(wsf, hsf, new_width, new_height)
-
-            return resized_img, crop_img_size
-
-        except Exception as e:
-            _LOGGER.debug(
-                "Error resizing image with aspect ratio: %s. %s", aspect_ratio, e
-            )
-            raise ValueError("Error resizing image with aspect ratio") from e
-
-    # If no aspect ratio is provided, return the original image and default crop size
-    return pil_img, crop_img_size

{valetudo_map_parser-0.1.9b3 → valetudo_map_parser-0.1.9b5}/SCR/valetudo_map_parser/map_data.py

@@ -10,12 +10,7 @@ from __future__ import annotations
 
 import numpy as np
 
-from .config.types import (
-    Colors,
-    ImageSize,
-    JsonType,
-    NumpyArray,
-)
+from .config.types import Colors, ImageSize, JsonType, NumpyArray
 
 
 class ImageData:

{valetudo_map_parser-0.1.9b3 → valetudo_map_parser-0.1.9b5}/SCR/valetudo_map_parser/rand25_handler.py

@@ -9,13 +9,22 @@ from __future__ import annotations
 
 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 PIL import Image
+
 from .config.auto_crop import AutoCrop
-from .images_utils import ImageUtils as ImUtils
+from .config.types import (
+    COLORS,
+    DEFAULT_IMAGE_SIZE,
+    DEFAULT_PIXEL_SIZE,
+    Colors,
+    JsonType,
+    PilPNG,
+    RobotPosition,
+    RoomsProperties,
+)
+from .config.utils import BaseHandler
 from .map_data import RandImageData
 from .reimg_draw import ImageDraw
 
@@ -23,33 +32,23 @@ _LOGGER = logging.getLogger(__name__)
 
 
 # noinspection PyTypeChecker
-class ReImageHandler:
+class ReImageHandler(BaseHandler):
     """
     Image Handler for Valetudo Re Vacuums.
     """
 
     def __init__(self, camera_shared):
+        super().__init__()
         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 = []  # 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
         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
@@ -65,7 +64,6 @@ class ReImageHandler:
         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(
@@ -177,7 +175,7 @@ class ReImageHandler:
 
                 # Increment frame number
                 self.frame_number += 1
-                img_np_array = await self.imd.async_copy_array(self.img_base_layer)
+                img_np_array = await self.async_copy_array(self.img_base_layer)
                 _LOGGER.debug(
                     "%s: Frame number %s", self.file_name, str(self.frame_number)
                 )
@@ -231,7 +229,7 @@ class ReImageHandler:
                         (robot_position[1] * 10),
                         robot_position_angle,
                     )
-            self.img_base_layer = await self.imd.async_copy_array(img_np_array)
+            self.img_base_layer = await self.async_copy_array(img_np_array)
         return self.img_base_layer, robot_position, robot_position_angle
 
     async def _draw_map_elements(
@@ -276,59 +274,12 @@ class ReImageHandler:
             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),
+                pil_img = await self.async_resize_image(
+                    pil_img, width, height, self.shared.image_aspect_ratio, True
                 )
-                _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:
-        """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:
@@ -427,15 +378,7 @@ class ReImageHandler:
             )
 
             # 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
-            ]
+            map_points = self.get_map_points()
 
             # Valetudo Re version need corrections of the coordinates and are implemented with *10
             vacuum_points = self.imu.re_get_vacuum_points(rotation_angle)
@@ -446,24 +389,3 @@ class ReImageHandler:
                 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-0.1.9b3 → valetudo_map_parser-0.1.9b5}/SCR/valetudo_map_parser/reimg_draw.py

@@ -10,10 +10,9 @@ import hashlib
 import json
 import logging
 
-from .config.types import Color, JsonType, NumpyArray
 from .config.drawable import Drawable
-from .map_data import RandImageData
-from .map_data import ImageData
+from .config.types import Color, JsonType, NumpyArray
+from .map_data import ImageData, RandImageData
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -300,25 +299,6 @@ class ImageDraw:
             _LOGGER.info("%s: Got the points in the json.", self.file_name)
         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

{valetudo_map_parser-0.1.9b3 → valetudo_map_parser-0.1.9b5}/pyproject.toml

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

{valetudo_map_parser-0.1.9b3 → valetudo_map_parser-0.1.9b5}/SCR/valetudo_map_parser/__init__.py

@@ -1,20 +1,20 @@
 """Valetudo map parser.
 Version: 0.1.8"""
 
-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
+from .config.rand25_parser import RRMapParser
+from .config.shared import CameraShared, CameraSharedManager
 from .config.types import (
-    SnapshotStore,
-    UserLanguageStore,
-    RoomStore,
+    CameraModes,
     RoomsProperties,
+    RoomStore,
+    SnapshotStore,
     TrimCropData,
-    CameraModes,
+    UserLanguageStore,
 )
+from .hypfer_handler import HypferMapImageHandler
+from .rand25_handler import ReImageHandler
 
 __all__ = [
     "HypferMapImageHandler",

{valetudo_map_parser-0.1.9b3 → valetudo_map_parser-0.1.9b5}/SCR/valetudo_map_parser/config/drawable.py

@@ -10,8 +10,8 @@ from __future__ import annotations
 
 import math
 
-from PIL import ImageDraw, ImageFont
 import numpy as np
+from PIL import ImageDraw, ImageFont
 
 from .types import Color, NumpyArray, PilPNG, Point, Union
 

{valetudo_map_parser-0.1.9b3 → valetudo_map_parser-0.1.9b5}/SCR/valetudo_map_parser/config/types.py

@@ -4,13 +4,13 @@ Version 0.0.1
 """
 
 import asyncio
-from dataclasses import dataclass
 import json
 import logging
+from dataclasses import dataclass
 from typing import Any, Dict, Tuple, Union
 
-from PIL import Image
 import numpy as np
+from PIL import Image
 
 DEFAULT_ROOMS = 1