valetudo-map-parser 0.1.9b4__py3-none-any.whl → 0.1.9b5__py3-none-any.whl

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/hypfer_draw.py

@@ -6,8 +6,6 @@ Version: 2024.07.2
 
 from __future__ import annotations
 
-import hashlib
-import json
 import logging
 
 from .config.types import Color, JsonType, NumpyArray, RobotPosition
@@ -283,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/hypfer_handler.py

@@ -13,53 +13,34 @@ import logging
 from PIL import Image
 
 from .config.auto_crop import AutoCrop
-from .config.colors import ColorsManagment, SupportedColor
 from .config.drawable import Drawable
 from .config.shared import CameraShared
-from .config.types import (
-    CalibrationPoints,
-    ChargerPosition,
-    ImageSize,
-    RobotPosition,
-    RoomsProperties,
-)
+from .config.types import COLORS, CalibrationPoints, Colors, RoomsProperties
+from .config.utils import BaseHandler
 from .hypfer_draw import ImageDraw as ImDraw
-from .images_utils import ImageUtils as ImUtils
-from .images_utils import resize_to_aspect_ratio
 from .map_data import ImageData
 
 _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.
@@ -73,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."""
@@ -128,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,
@@ -157,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:
@@ -186,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():
@@ -199,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:
@@ -228,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 (
@@ -242,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(
@@ -300,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)
@@ -322,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."""
@@ -364,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)
 
@@ -382,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/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/rand25_handler.py

@@ -11,7 +11,7 @@ import logging
 import uuid
 from typing import Any
 
-from PIL import Image, ImageOps
+from PIL import Image
 
 from .config.auto_crop import AutoCrop
 from .config.types import (
@@ -24,7 +24,7 @@ from .config.types import (
     RobotPosition,
     RoomsProperties,
 )
-from .images_utils import ImageUtils as ImUtils
+from .config.utils import BaseHandler
 from .map_data import RandImageData
 from .reimg_draw import ImageDraw
 
@@ -32,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
@@ -74,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(
@@ -186,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)
                 )
@@ -240,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(
@@ -285,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
+                pil_img = await self.async_resize_image(
+                    pil_img, width, height, self.shared.image_aspect_ratio, True
                 )
-                _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:
-        """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:
@@ -436,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)
@@ -455,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/reimg_draw.py

@@ -299,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.9b4.dist-info → valetudo_map_parser-0.1.9b5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b4
+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.9b4.dist-info → valetudo_map_parser-0.1.9b5.dist-info}/RECORD

@@ -6,15 +6,16 @@ valetudo_map_parser/config/drawable.py,sha256=hsrEJCMVOrjs5sJfr26SeqJD0VNlYWwxcV
 valetudo_map_parser/config/rand25_parser.py,sha256=fehyF18hRWRWbXbojocQCIaIch21Lbh1wtl2XdKRSl0,16447
 valetudo_map_parser/config/shared.py,sha256=LQV5K8tbVhEKUkby9ssjEmh_T4Ai-Euzsbag_HWYVRc,9448
 valetudo_map_parser/config/types.py,sha256=-8F1WwCH5hKSih83-WPjYbGdQyKmNqkDmSKvlyz6qPg,16163
-valetudo_map_parser/hypfer_draw.py,sha256=YuxkAUfWphnyHLyUyTlMTvQlxRtfkTZalzV3cQkiqDs,15752
-valetudo_map_parser/hypfer_handler.py,sha256=LpC2ez-XEioURzbOYlg89BKC7N21txKDe835rxBxcJs,18456
-valetudo_map_parser/images_utils.py,sha256=0Baq48oncJy6Z_HxaRhMuknt3TMhBxl92BGDGhw-HYo,15262
+valetudo_map_parser/config/utils.py,sha256=l59-8LtDlFpUbqVL1ZSdmvNOpNuo65JwGnxUI7SYp9k,4728
+valetudo_map_parser/hypfer_draw.py,sha256=JFiWb-06WI1Gt0TrIl2ieBVLHe1_zxh4h9N7V5dXtaM,14951
+valetudo_map_parser/hypfer_handler.py,sha256=lb3pTS48C0O_twOCIyz6K1DAO8Cpg78WpbbQZ3LMkE8,14211
+valetudo_map_parser/images_utils.py,sha256=1HMf57CODrgfIsIxKAmHcfiylitQ-wUPEsYoqiGqHbo,12947
 valetudo_map_parser/map_data.py,sha256=qm1Zlfex0JrfhQsAKUOzsceZL0X92oAyGJ5Wvsq6YhA,19447
 valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand25_handler.py,sha256=gHVoD5SrgViXVoUQTKb0AImdh2kWfzaRPFtco1kt3_0,19566
-valetudo_map_parser/reimg_draw.py,sha256=RpqPEjVOF0W2Ug7QhqB2ZI3KI_GBs9Sbo_7A7E9Lt_4,13307
-valetudo_map_parser-0.1.9b4.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b4.dist-info/METADATA,sha256=zqs2g9pQpNfMw2veVYffGtMc5r2v0Alb4AS7LXZYInM,1028
-valetudo_map_parser-0.1.9b4.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b4.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-valetudo_map_parser-0.1.9b4.dist-info/RECORD,,
+valetudo_map_parser/rand25_handler.py,sha256=htoWivyLFs1xK6ca8E4zx2k9Zf4mNPGcpw4l-5xAfH0,15959
+valetudo_map_parser/reimg_draw.py,sha256=yozq4QesZVljZwFcWOXm_65AUxhD_9KwJUjnf9tqPCg,12533
+valetudo_map_parser-0.1.9b5.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b5.dist-info/METADATA,sha256=AUp_Ttj2g0gM0u5TINPEfkSnfMepqjqtzZy36Y5fiXw,1028
+valetudo_map_parser-0.1.9b5.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b5.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+valetudo_map_parser-0.1.9b5.dist-info/RECORD,,