valetudo-map-parser 0.1.9b8__py3-none-any.whl → 0.1.9b9__py3-none-any.whl

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/config/utils.py

@@ -32,6 +32,7 @@ class BaseHandler:
         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."""
@@ -53,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:
@@ -105,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 = {
@@ -121,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
@@ -446,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/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/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(
                         {
@@ -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/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/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.9b8.dist-info → valetudo_map_parser-0.1.9b9.dist-info}/METADATA

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

@@ -5,16 +5,16 @@ valetudo_map_parser/config/colors.py,sha256=0sTI_x0ZMchSDPTsEivdTXDn58nEbyE4REXI
 valetudo_map_parser/config/drawable.py,sha256=hsrEJCMVOrjs5sJfr26SeqJD0VNlYWwxcVkkHeaxx7U,20356
 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/config/utils.py,sha256=V_GmVL10hLaGWRltv8FvxEEohRfswWDmmnp6HA0vsn8,16627
-valetudo_map_parser/hypfer_draw.py,sha256=46bYtbcaZHDYDtOie4byM3Z8CcXw-vl7uQfwN7KdZOk,14958
-valetudo_map_parser/hypfer_handler.py,sha256=hBYy6trd1hmFkyOPJmm1T-y4byi-xGqS8yN_Xwhl0E0,14073
-valetudo_map_parser/map_data.py,sha256=qm1Zlfex0JrfhQsAKUOzsceZL0X92oAyGJ5Wvsq6YhA,19447
+valetudo_map_parser/config/types.py,sha256=sdjqhcxpRSxNFLVHIyCg-RDL9JIjtQHoR2C2WpocWBc,16107
+valetudo_map_parser/config/utils.py,sha256=eK7Ai5G6Za9U_kNwER2Z6ELwHmJMkflGtLGufE6FHb0,17515
+valetudo_map_parser/hypfer_draw.py,sha256=s58ak9IBYLjJyoddfDC99PfQ12HTjkSfJYXqCi4vZKs,14931
+valetudo_map_parser/hypfer_handler.py,sha256=lA9rC4gO0cNas4ValRikw4X6Uc0sqo2-Roj7EQi1MBA,13471
+valetudo_map_parser/map_data.py,sha256=6FbQfgxFB6E4kcOWokReJOVSekVaE1kStyhTQhAhiOg,19469
 valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand25_handler.py,sha256=vph1BCO0g77kTi18y6sqqJfyJfT5033l9CoxJIDO1Ak,15827
+valetudo_map_parser/rand25_handler.py,sha256=xvnUAd5C3byGx7j1u2QmNlSCVDcuDOHa89PUdsVRfgc,15277
 valetudo_map_parser/reimg_draw.py,sha256=dtdbYKKxmQnbOaHBHayWEF07OdSnTKo2CPSOW0qpgH0,12506
-valetudo_map_parser-0.1.9b8.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b8.dist-info/METADATA,sha256=uoqN0vHYxk79Tfy0Sq4D9aiHjbjwm2gzqUxQbxD3WPU,1028
-valetudo_map_parser-0.1.9b8.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b8.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-valetudo_map_parser-0.1.9b8.dist-info/RECORD,,
+valetudo_map_parser-0.1.9b9.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b9.dist-info/METADATA,sha256=uXL383aQm_sHMQKIRs0AM2iAJIeilsMy1uit9KnMqm8,1028
+valetudo_map_parser-0.1.9b9.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b9.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+valetudo_map_parser-0.1.9b9.dist-info/RECORD,,