valetudo-map-parser 0.1.9b7__tar.gz → 0.1.9b9__tar.gz

{valetudo_map_parser-0.1.9b7 → valetudo_map_parser-0.1.9b9}/PKG-INFO

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

@@ -203,7 +203,6 @@ class SnapshotStore:
 
 
 CAMERA_STORAGE = "valetudo_camera"
-DEFAULT_ROOMS = 1  # 15 is the maximum number of rooms.
 ATTR_ROTATE = "rotate_image"
 ATTR_CROP = "crop_image"
 ATTR_MARGINS = "margins"

{valetudo_map_parser-0.1.9b7 → valetudo_map_parser-0.1.9b9}/SCR/valetudo_map_parser/config/utils.py

@@ -31,6 +31,8 @@ class BaseHandler:
         self.offset_x = 0
         self.offset_y = 0
         self.shared = None
+        self.crop_area = [0, 0, 0, 0]
+        self.zooming = False
 
     def get_frame_number(self) -> int:
         """Return the frame number of the image."""
@@ -52,10 +54,22 @@ class BaseHandler:
         """Return the JSON ID from the image."""
         return self.json_id
 
+    def check_zoom_and_aspect_ratio(self) -> bool:
+        """Check if the image is zoomed and has an aspect ratio."""
+        return (
+                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"
+        )
+
     async def async_resize_image(
-        self, pil_img, width, height, aspect_ratio=None, is_rand=False
+        self, pil_img, aspect_ratio=None, is_rand=False
     ):
         """Resize the image to the given dimensions and aspect ratio."""
+        width = self.shared.image_ref_width
+        height = self.shared.image_ref_height
         if aspect_ratio:
             wsf, hsf = [int(x) for x in aspect_ratio.split(",")]
             if wsf == 0 or hsf == 0:
@@ -104,7 +118,7 @@ class BaseHandler:
         return width, height
 
     @staticmethod
-    async def calculate_array_hash(layers: dict, active: list[int] = None) -> str:
+    async def calculate_array_hash(layers: dict, active: list[int] = None) -> str or None:
         """Calculate the hash of the image based on layers and active zones."""
         if layers and active:
             data_to_hash = {
@@ -120,17 +134,17 @@ class BaseHandler:
         """Copy the array."""
         return NumpyArray.copy(original_array)
 
-    def get_map_points(self) -> dict:
+    def get_map_points(self) -> list[dict[str, int] | dict[str, int] | dict[str, int] | dict[str, int]]:
         """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
-        ]
+                {"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
+            ]
 
     def set_image_offset_ratio_1_1(
             self, width: int, height: int, rand256: bool = False
@@ -316,20 +330,20 @@ class BaseHandler:
         # get_calibration_data
         vacuum_points = [
             {
-                "x": self.img.crop_area[0] + self.img.offset_x,
-                "y": self.img.crop_area[1] + self.img.offset_y,
+                "x": self.crop_area[0] + self.offset_x,
+                "y": self.crop_area[1] + self.offset_y,
             },  # Top-left corner 0
             {
-                "x": self.img.crop_area[2] - self.img.offset_x,
-                "y": self.img.crop_area[1] + self.img.offset_y,
+                "x": self.crop_area[2] - self.offset_x,
+                "y": self.crop_area[1] + self.offset_y,
             },  # Top-right corner 1
             {
-                "x": self.img.crop_area[2] - self.img.offset_x,
-                "y": self.img.crop_area[3] - self.img.offset_y,
+                "x": self.crop_area[2] - self.offset_x,
+                "y": self.crop_area[3] - self.offset_y,
             },  # Bottom-right corner 2
             {
-                "x": self.img.crop_area[0] + self.img.offset_x,
-                "y": self.img.crop_area[3] - self.img.offset_y,
+                "x": self.crop_area[0] + self.offset_x,
+                "y": self.crop_area[3] - self.offset_y,
             },  # Bottom-left corner (optional)3
         ]
 
@@ -363,20 +377,20 @@ class BaseHandler:
         RAND256 Vacuums Calibration Points are in 10th of a mm."""
         vacuum_points = [
             {
-                "x": ((self.img.crop_area[0] + self.img.offset_x) * 10),
-                "y": ((self.img.crop_area[1] + self.img.offset_y) * 10),
+                "x": ((self.crop_area[0] + self.offset_x) * 10),
+                "y": ((self.crop_area[1] + self.offset_y) * 10),
             },  # Top-left corner 0
             {
-                "x": ((self.img.crop_area[2] - self.img.offset_x) * 10),
-                "y": ((self.img.crop_area[1] + self.img.offset_y) * 10),
+                "x": ((self.crop_area[2] - self.offset_x) * 10),
+                "y": ((self.crop_area[1] + self.offset_y) * 10),
             },  # Top-right corner 1
             {
-                "x": ((self.img.crop_area[2] - self.img.offset_x) * 10),
-                "y": ((self.img.crop_area[3] - self.img.offset_y) * 10),
+                "x": ((self.crop_area[2] - self.offset_x) * 10),
+                "y": ((self.crop_area[3] - self.offset_y) * 10),
             },  # Bottom-right corner 2
             {
-                "x": ((self.img.crop_area[0] + self.img.offset_x) * 10),
-                "y": ((self.img.crop_area[3] - self.img.offset_y) * 10),
+                "x": ((self.crop_area[0] + self.offset_x) * 10),
+                "y": ((self.crop_area[3] - self.offset_y) * 10),
             },  # Bottom-left corner (optional)3
         ]
 
@@ -445,4 +459,14 @@ class BaseHandler:
                 id_count += 1
             if id_count > 1:
                 _LOGGER.debug("%s: Point Properties updated.", self.file_name)
-        return point_properties
+        return point_properties
+
+    @staticmethod
+    def get_corners(x_max:int, x_min:int, y_max:int, y_min:int) -> list[tuple[int, int]]:
+        """Return the corners of the image."""
+        return [
+        (x_min, y_min),
+        (x_max, y_min),
+        (x_max, y_max),
+        (x_min, y_max),
+        ]

{valetudo_map_parser-0.1.9b7 → valetudo_map_parser-0.1.9b9}/SCR/valetudo_map_parser/hypfer_draw.py

@@ -262,9 +262,9 @@ class ImageDraw:
             for path in path_pixels:
                 # Get the points from the current path and extend multiple paths.
                 points = path.get("points", [])
-                sublists = self.img_h.data.sublist(points, 2)
+                sublist = self.img_h.data.sublist(points, 2)
                 self.img_h.shared.map_new_path = self.img_h.data.sublist_join(
-                    sublists, 2
+                    sublist, 2
                 )
                 np_array = await self.img_h.draw.lines(
                     np_array, self.img_h.shared.map_new_path, 5, color_move
@@ -276,9 +276,8 @@ class ImageDraw:
         try:
             entity_dict = self.img_h.data.find_points_entities(m_json)
         except (ValueError, KeyError):
-            entity_dict = None
-        else:
-            _LOGGER.info("%s: Got the points in the json.", self.file_name)
+            return None
+        _LOGGER.info("%s: Got the points in the json.", self.file_name)
         return entity_dict
 
     async def async_get_robot_in_room(

{valetudo_map_parser-0.1.9b7 → valetudo_map_parser-0.1.9b9}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -40,8 +40,6 @@ class HypferMapImageHandler(BaseHandler):
         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.active_zones = None  # vacuum active zones.
-        self.frame_number = 0  # frame number of the image.
-        self.zooming = False  # zooming the image.
         self.svg_wait = False  # SVG image creation wait.
         self.trim_down = 0  # memory stored trims calculated once.
         self.trim_left = 0  # memory stored trims calculated once.
@@ -78,12 +76,7 @@ class HypferMapImageHandler(BaseHandler):
                         x_max,
                         y_max,
                     ) = await self.data.async_get_rooms_coordinates(pixels, pixel_size)
-                    corners = [
-                        (x_min, y_min),
-                        (x_max, y_min),
-                        (x_max, y_max),
-                        (x_min, y_max),
-                    ]
+                    corners = self.get_corners(x_max, x_min, y_max, y_min)
                     room_id = str(segment_id)
                     self.rooms_pos.append(
                         {
@@ -207,7 +200,7 @@ class HypferMapImageHandler(BaseHandler):
                 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.async_draw_zones(
+                img_np_array = await self.imd.async_draw_zones(
                     m_json,
                     img_np_array,
                     colors["zone_clean"],
@@ -253,17 +246,9 @@ class HypferMapImageHandler(BaseHandler):
             pil_img = Image.fromarray(img_np_array, mode="RGBA")
             del img_np_array
             # 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.check_zoom_and_aspect_ratio():
                 resized_image = await self.async_resize_image(
-                    pil_img, width, height, self.shared.image_aspect_ratio
+                    pil_img, self.shared.image_aspect_ratio
                 )
                 return resized_image
             _LOGGER.debug("%s: Frame Completed.", self.file_name)

{valetudo_map_parser-0.1.9b7 → valetudo_map_parser-0.1.9b9}/SCR/valetudo_map_parser/map_data.py

@@ -239,7 +239,7 @@ class RandImageData:
         return compressed_pixels
 
     @staticmethod
-    def calculate_max_x_y(coord_array):
+    def _calculate_max_x_y(coord_array):
         """Calculate the max and min x and y coordinates."""
         max_x = -float("inf")
         max_y = -float("inf")
@@ -334,18 +334,18 @@ class RandImageData:
     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 = RandImageData.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 = RandImageData.rrm_valetudo_format_zone(re_zones)
+        formatted_zones = RandImageData._rrm_valetudo_format_zone(re_zones)
         return formatted_zones
 
     @staticmethod
-    def rrm_valetudo_format_zone(coordinates: list) -> any:
+    def _rrm_valetudo_format_zone(coordinates: list) -> any:
         """Format the zones from RRM to Valetudo."""
         formatted_zones = []
         for zone_data in coordinates:
@@ -387,7 +387,7 @@ class RandImageData:
         return formatted_zones
 
     @staticmethod
-    def rrm_valetudo_lines(coordinates: list) -> list:
+    def _rrm_valetudo_lines(coordinates: list) -> list:
         """Format the lines from RRM to Valetudo."""
         formatted_lines = []
         for lines in coordinates:
@@ -402,7 +402,7 @@ class RandImageData:
             tmp_data = json_data.get("virtual_walls", [])
         except KeyError:
             return None
-        virtual_walls = RandImageData.rrm_valetudo_lines(tmp_data)
+        virtual_walls = RandImageData._rrm_valetudo_lines(tmp_data)
         return virtual_walls
 
     @staticmethod
@@ -495,11 +495,11 @@ class RandImageData:
             return None
         return seg_ids
 
-    @staticmethod
-    def convert_negative_angle(angle: int) -> int:
-        """Convert negative angle to positive."""
-        angle_c = angle % 360  # Ensure angle is within 0-359
-        if angle_c < 0:
-            angle_c += 360  # Convert negative angle to positive
-        angle = angle_c + 180  # add offset
-        return angle
+    # @staticmethod
+    # def convert_negative_angle(angle: int) -> int:
+    #     """Convert negative angle to positive."""
+    #     angle_c = angle % 360  # Ensure angle is within 0-359
+    #     if angle_c < 0:
+    #         angle_c += 360  # Convert negative angle to positive
+    #     angle = angle_c + 180  # add offset
+    #     return angle

{valetudo_map_parser-0.1.9b7 → valetudo_map_parser-0.1.9b9}/SCR/valetudo_map_parser/rand25_handler.py

@@ -55,14 +55,13 @@ class ReImageHandler(BaseHandler):
         self.trim_left = None  # Trim left
         self.trim_right = None  # Trim right
         self.trim_up = None  # Trim up
-        self.zooming = False  # Zooming flag
         self.file_name = self.shared.file_name  # File name
         self.offset_top = self.shared.offset_top  # offset top
         self.offset_bottom = self.shared.offset_down  # offset bottom
         self.offset_left = self.shared.offset_left  # offset left
         self.offset_right = self.shared.offset_right  # offset right
         self.imd = ImageDraw(self)  # Image Draw
-        self.ac = AutoCrop(self)
+        self.crop = AutoCrop(self)
 
     async def extract_room_properties(
         self, json_data: JsonType, destinations: JsonType
@@ -96,12 +95,7 @@ class ReImageHandler(BaseHandler):
                         x_max = self.outlines[id_x][1][0]
                         y_min = self.outlines[id_x][0][1]
                         y_max = self.outlines[id_x][1][1]
-                        corners = [
-                            (x_min, y_min),
-                            (x_max, y_min),
-                            (x_max, y_max),
-                            (x_min, y_max),
-                        ]
+                        corners = self.get_corners(x_max, x_min, y_max, y_min)
                         # rand256 vacuums accept int(room_id) or str(name)
                         # the card will soon support int(room_id) but the camera will send name
                         # this avoids the manual change of the values in the card.
@@ -251,30 +245,21 @@ class ReImageHandler(BaseHandler):
         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 = await self.crop.async_auto_trim_and_zoom_image(
             img_np_array,
-            colors["background"],
-            int(self.shared.margins),
-            int(self.shared.image_rotate),
-            self.zooming,
+            detect_colour=colors["background"],
+            margin_size=int(self.shared.margins),
+            rotate=int(self.shared.image_rotate),
+            zoom=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":
-                pil_img = await self.async_resize_image(
-                    pil_img, width, height, self.shared.image_aspect_ratio, True
-                )
+        if self.check_zoom_and_aspect_ratio() :
+            pil_img = await self.async_resize_image(
+                pil_img, self.shared.image_aspect_ratio, True
+            )
         _LOGGER.debug("%s: Frame Completed.", self.file_name)
         return pil_img
 

{valetudo_map_parser-0.1.9b7 → valetudo_map_parser-0.1.9b9}/pyproject.toml

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