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

valetudo_map_parser/config/utils.py

@@ -6,7 +6,6 @@ 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__)
@@ -29,7 +28,9 @@ class BaseHandler:
         self.frame_number = 0
         self.max_frames = 1024
         self.crop_img_size = [0, 0]
-        self.imu = ImUtils(self)  # Image Utils
+        self.offset_x = 0
+        self.offset_y = 0
+        self.shared = None
 
     def get_frame_number(self) -> int:
         """Return the frame number of the image."""
@@ -89,17 +90,17 @@ class BaseHandler:
         """
 
         if wsf == 1 and hsf == 1:
-            self.imu.set_image_offset_ratio_1_1(width, height, rand256)
+            self.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)
+            self.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)
+            self.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)
+            self.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)
+            self.set_image_offset_ratio_9_16(width, height, rand256)
         elif wsf == 16 and hsf == 9:
-            self.imu.set_image_offset_ratio_16_9(width, height, rand256=True)
+            self.set_image_offset_ratio_16_9(width, height, rand256)
         return width, height
 
     @staticmethod
@@ -130,3 +131,318 @@ class BaseHandler:
             },  # 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
+    ) -> None:
+        """Set the image offset ratio to 1:1."""
+
+        rotation = self.shared.image_rotate
+        if not rand256:
+            if rotation in [0, 180]:
+                self.offset_y = self.crop_img_size[0] - width
+                self.offset_x = (height - self.crop_img_size[1]) // 2
+            elif rotation in [90, 270]:
+                self.offset_y = width - self.crop_img_size[0]
+                self.offset_x = (self.crop_img_size[1] - height) // 2
+        else:
+            if rotation in [0, 180]:
+                self.offset_x = (width - self.crop_img_size[0]) // 2
+                self.offset_y = height - self.crop_img_size[1]
+            elif rotation in [90, 270]:
+                self.offset_y = (self.crop_img_size[0] - width) // 2
+                self.offset_x = self.crop_img_size[1] - height
+        _LOGGER.debug(
+            "%s Image Coordinates Offsets (x,y): %s. %s",
+            self.file_name,
+            self.offset_x,
+            self.offset_y,
+        )
+
+    def set_image_offset_ratio_2_1(
+            self, width: int, height: int, rand256: bool = False
+    ) -> None:
+        """Set the image offset ratio to 2:1."""
+
+        rotation = self.shared.image_rotate
+        if not rand256:
+            if rotation in [0, 180]:
+                self.offset_y = width - self.crop_img_size[0]
+                self.offset_x = height - self.crop_img_size[1]
+            elif rotation in [90, 270]:
+                self.offset_x = width - self.crop_img_size[0]
+                self.offset_y = height - self.crop_img_size[1]
+        else:
+            if rotation in [0, 180]:
+                self.offset_y = width - self.crop_img_size[0]
+                self.offset_x = height - self.crop_img_size[1]
+            elif rotation in [90, 270]:
+                self.offset_x = width - self.crop_img_size[0]
+                self.offset_y = height - self.crop_img_size[1]
+
+        _LOGGER.debug(
+            "%s Image Coordinates Offsets (x,y): %s. %s",
+            self.file_name,
+            self.offset_x,
+            self.offset_y,
+        )
+
+    def set_image_offset_ratio_3_2(
+            self, width: int, height: int, rand256: bool = False
+    ) -> None:
+        """Set the image offset ratio to 3:2."""
+
+        rotation = self.shared.image_rotate
+
+        if not rand256:
+            if rotation in [0, 180]:
+                self.offset_y = width - self.crop_img_size[0]
+                self.offset_x = ((height - self.crop_img_size[1]) // 2) - (
+                        self.crop_img_size[1] // 10
+                )
+            elif rotation in [90, 270]:
+                self.offset_y = (self.crop_img_size[0] - width) // 2
+                self.offset_x = (self.crop_img_size[1] - height) + (
+                        (height // 10) // 2
+                )
+        else:
+            if rotation in [0, 180]:
+                self.offset_x = (width - self.crop_img_size[0]) // 2
+                self.offset_y = height - self.crop_img_size[1]
+            elif rotation in [90, 270]:
+                self.offset_y = (self.crop_img_size[0] - width) // 2
+                self.offset_x = self.crop_img_size[1] - height
+
+        _LOGGER.debug(
+            "%s Image Coordinates Offsets (x,y): %s. %s",
+            self.file_name,
+            self.offset_x,
+            self.offset_y,
+        )
+
+    def set_image_offset_ratio_5_4(
+            self, width: int, height: int, rand256: bool = False
+    ) -> None:
+        """Set the image offset ratio to 5:4."""
+
+        rotation = self.shared.image_rotate
+        if not rand256:
+            if rotation in [0, 180]:
+                self.offset_x = ((width - self.crop_img_size[0]) // 2) - (
+                        self.crop_img_size[0] // 2
+                )
+                self.offset_y = (self.crop_img_size[1] - height) - (
+                        self.crop_img_size[1] // 2
+                )
+            elif rotation in [90, 270]:
+                self.offset_y = ((self.crop_img_size[0] - width) // 2) - 10
+                self.offset_x = (self.crop_img_size[1] - height) + (
+                        height // 10
+                )
+        else:
+            if rotation in [0, 180]:
+                self.offset_y = (width - self.crop_img_size[0]) // 2
+                self.offset_x = self.crop_img_size[1] - height
+            elif rotation in [90, 270]:
+                self.offset_y = (self.crop_img_size[0] - width) // 2
+                self.offset_x = self.crop_img_size[1] - height
+
+        _LOGGER.debug(
+            "%s Image Coordinates Offsets (x,y): %s. %s",
+            self.file_name,
+            self.offset_x,
+            self.offset_y,
+        )
+
+    def set_image_offset_ratio_9_16(
+            self, width: int, height: int, rand256: bool = False
+    ) -> None:
+        """Set the image offset ratio to 9:16."""
+
+        rotation = self.shared.image_rotate
+        if not rand256:
+            if rotation in [0, 180]:
+                self.offset_y = width - self.crop_img_size[0]
+                self.offset_x = height - self.crop_img_size[1]
+            elif rotation in [90, 270]:
+                self.offset_x = (width - self.crop_img_size[0]) + (height // 10)
+                self.offset_y = height - self.crop_img_size[1]
+        else:
+            if rotation in [0, 180]:
+                self.offset_y = width - self.crop_img_size[0]
+                self.offset_x = height - self.crop_img_size[1]
+            elif rotation in [90, 270]:
+                self.offset_x = width - self.crop_img_size[0]
+                self.offset_y = height - self.crop_img_size[1]
+
+        _LOGGER.debug(
+            "%s Image Coordinates Offsets (x,y): %s. %s",
+            self.file_name,
+            self.offset_x,
+            self.offset_y,
+        )
+
+    def set_image_offset_ratio_16_9(
+            self, width: int, height: int, rand256: bool = False
+    ) -> None:
+        """Set the image offset ratio to 16:9."""
+
+        rotation = self.shared.image_rotate
+        if not rand256:
+            if rotation in [0, 180]:
+                self.offset_y = width - self.crop_img_size[0]
+                self.offset_x = height - self.crop_img_size[1]
+            elif rotation in [90, 270]:
+                self.offset_x = width - self.crop_img_size[0]
+                self.offset_y = height - self.crop_img_size[1]
+        else:
+            if rotation in [0, 180]:
+                self.offset_y = width - self.crop_img_size[0]
+                self.offset_x = height - self.crop_img_size[1]
+            elif rotation in [90, 270]:
+                self.offset_x = width - self.crop_img_size[0]
+                self.offset_y = height - self.crop_img_size[1]
+
+        _LOGGER.debug(
+            "%s Image Coordinates Offsets (x,y): %s. %s",
+            self.file_name,
+            self.offset_x,
+            self.offset_y,
+        )
+
+    def get_vacuum_points(self, rotation_angle: int) -> list[dict[str, int]]:
+        """Calculate the calibration points based on the rotation angle."""
+
+        # 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,
+            },  # Top-left corner 0
+            {
+                "x": self.img.crop_area[2] - self.img.offset_x,
+                "y": self.img.crop_area[1] + self.img.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,
+            },  # Bottom-right corner 2
+            {
+                "x": self.img.crop_area[0] + self.img.offset_x,
+                "y": self.img.crop_area[3] - self.img.offset_y,
+            },  # Bottom-left corner (optional)3
+        ]
+
+        # Rotate the vacuum points based on the rotation angle
+        if rotation_angle == 90:
+            vacuum_points = [
+                vacuum_points[1],
+                vacuum_points[2],
+                vacuum_points[3],
+                vacuum_points[0],
+            ]
+        elif rotation_angle == 180:
+            vacuum_points = [
+                vacuum_points[2],
+                vacuum_points[3],
+                vacuum_points[0],
+                vacuum_points[1],
+            ]
+        elif rotation_angle == 270:
+            vacuum_points = [
+                vacuum_points[3],
+                vacuum_points[0],
+                vacuum_points[1],
+                vacuum_points[2],
+            ]
+
+        return vacuum_points
+
+    def re_get_vacuum_points(self, rotation_angle: int) -> list[dict[str, int]]:
+        """Recalculate the calibration points based on the rotation angle.
+        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),
+            },  # 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),
+            },  # 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),
+            },  # 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),
+            },  # Bottom-left corner (optional)3
+        ]
+
+        # Rotate the vacuum points based on the rotation angle
+        if rotation_angle == 90:
+            vacuum_points = [
+                vacuum_points[1],
+                vacuum_points[2],
+                vacuum_points[3],
+                vacuum_points[0],
+            ]
+        elif rotation_angle == 180:
+            vacuum_points = [
+                vacuum_points[2],
+                vacuum_points[3],
+                vacuum_points[0],
+                vacuum_points[1],
+            ]
+        elif rotation_angle == 270:
+            vacuum_points = [
+                vacuum_points[3],
+                vacuum_points[0],
+                vacuum_points[1],
+                vacuum_points[2],
+            ]
+
+        return vacuum_points
+
+    async def async_zone_propriety(self, zones_data) -> dict:
+        """Get the zone propriety"""
+        zone_properties = {}
+        id_count = 1
+        for zone in zones_data:
+            zone_name = zone.get("name")
+            coordinates = zone.get("coordinates")
+            if coordinates and len(coordinates) > 0:
+                coordinates[0].pop()
+                x1, y1, x2, y2 = coordinates[0]
+                zone_properties[zone_name] = {
+                    "zones": coordinates,
+                    "name": zone_name,
+                    "x": ((x1 + x2) // 2),
+                    "y": ((y1 + y2) // 2),
+                }
+                id_count += 1
+            if id_count > 1:
+                _LOGGER.debug("%s: Zones Properties updated.", self.file_name)
+        return zone_properties
+
+    async def async_points_propriety(self, points_data) -> dict:
+        """Get the point propriety"""
+        point_properties = {}
+        id_count = 1
+        for point in points_data:
+            point_name = point.get("name")
+            coordinates = point.get("coordinates")
+            if coordinates and len(coordinates) > 0:
+                coordinates = point.get("coordinates")
+                x1, y1 = coordinates
+                point_properties[id_count] = {
+                    "position": coordinates,
+                    "name": point_name,
+                    "x": x1,
+                    "y": y1,
+                }
+                id_count += 1
+            if id_count > 1:
+                _LOGGER.debug("%s: Point Properties updated.", self.file_name)
+        return point_properties

valetudo_map_parser/hypfer_draw.py

@@ -70,7 +70,7 @@ class ImageDraw:
         self, img_np_array, pixels, layer_type, room_id, pixel_size, color_zone_clean
     ):
         """Process a room layer (segment or floor)."""
-        room_color = self.img_h.rooms_colors[room_id]
+        room_color = self.img_h.shared.rooms_colors[room_id]
 
         try:
             if layer_type == "segment":

valetudo_map_parser/hypfer_handler.py

@@ -51,8 +51,6 @@ class HypferMapImageHandler(BaseHandler):
         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.offset_x = 0  # offset x for the aspect ratio.
-        self.offset_y = 0  # offset y for the aspect ratio.
         self.imd = ImDraw(self)
         self.ac = AutoCrop(self)
         self.color_grey = (128, 128, 128, 255)
@@ -221,7 +219,7 @@ class HypferMapImageHandler(BaseHandler):
                 )
                 # Draw path prediction and paths.
                 img_np_array = await self.imd.async_draw_paths(
-                    img_np_array, m_json, colors["color_move"], self.color_grey
+                    img_np_array, m_json, colors["move"], self.color_grey
                 )
                 # Check if the robot is docked.
                 if self.shared.vacuum_state == "docked":
@@ -235,13 +233,13 @@ class HypferMapImageHandler(BaseHandler):
                         x=robot_position[0],
                         y=robot_position[1],
                         angle=robot_position_angle,
-                        fill=colors["color_robot"],
+                        fill=colors["robot"],
                         robot_state=self.shared.vacuum_state,
                     )
                 # Resize the image
                 img_np_array = await self.ac.async_auto_trim_and_zoom_image(
                     img_np_array,
-                    colors["color_background"],
+                    colors["background"],
                     int(self.shared.margins),
                     int(self.shared.image_rotate),
                     self.zooming,
@@ -303,7 +301,7 @@ class HypferMapImageHandler(BaseHandler):
         # Define the map points (fixed)
         map_points = self.get_map_points()
         # Calculate the calibration points in the vacuum coordinate system
-        vacuum_points = self.imu.get_vacuum_points(rotation_angle)
+        vacuum_points = self.get_vacuum_points(rotation_angle)
 
         # Create the calibration data for each point
         for vacuum_point, map_point in zip(vacuum_points, map_points):

valetudo_map_parser/rand25_handler.py

@@ -57,8 +57,6 @@ class ReImageHandler(BaseHandler):
         self.trim_up = None  # Trim up
         self.zooming = False  # Zooming flag
         self.file_name = self.shared.file_name  # File name
-        self.offset_x = 0  # offset x for the aspect ratio.
-        self.offset_y = 0  # offset y for the aspect ratio.
         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
@@ -121,9 +119,9 @@ class ReImageHandler(BaseHandler):
                             "y": (y_min + y_max) // 2,
                         }
                 # get the zones and points data
-                zone_properties = await self.imu.async_zone_propriety(zones_data)
+                zone_properties = await self.async_zone_propriety(zones_data)
                 # get the points data
-                point_properties = await self.imu.async_points_propriety(points_data)
+                point_properties = await self.async_points_propriety(points_data)
                 if room_properties or zone_properties:
                     extracted_data = [
                         f"{len(room_properties)} Rooms" if room_properties else None,
@@ -381,7 +379,7 @@ class ReImageHandler(BaseHandler):
             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)
+            vacuum_points = self.re_get_vacuum_points(rotation_angle)
 
             # Create the calibration data for each point
             for vacuum_point, map_point in zip(vacuum_points, map_points):

valetudo_map_parser/reimg_draw.py

@@ -6,8 +6,6 @@ Version: 2024.12.0
 
 from __future__ import annotations
 
-import hashlib
-import json
 import logging
 
 from .config.drawable import Drawable

{valetudo_map_parser-0.1.9b5.dist-info → valetudo_map_parser-0.1.9b7.dist-info}/METADATA

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

@@ -6,16 +6,15 @@ 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/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/config/utils.py,sha256=W4meKptsRCAmfNLGPktFy1GiBM1F6tLLZW750VCwCJ8,16717
+valetudo_map_parser/hypfer_draw.py,sha256=46bYtbcaZHDYDtOie4byM3Z8CcXw-vl7uQfwN7KdZOk,14958
+valetudo_map_parser/hypfer_handler.py,sha256=u1-2AIjZyhKw0QvRT604Ns9NX7ARaACxwaiyktdOprQ,14069
 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=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,,
+valetudo_map_parser/rand25_handler.py,sha256=vph1BCO0g77kTi18y6sqqJfyJfT5033l9CoxJIDO1Ak,15827
+valetudo_map_parser/reimg_draw.py,sha256=dtdbYKKxmQnbOaHBHayWEF07OdSnTKo2CPSOW0qpgH0,12506
+valetudo_map_parser-0.1.9b7.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b7.dist-info/METADATA,sha256=hIplZAuQgbccfthgYE_z_6MLvTPhiR_4y8XOkcT3Hqg,1028
+valetudo_map_parser-0.1.9b7.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b7.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+valetudo_map_parser-0.1.9b7.dist-info/RECORD,,

valetudo_map_parser/images_utils.py

@@ -1,335 +0,0 @@
-"""
-Image Utils Class for Valetudo Hypfer Image Handling.
-This class is used to simplify the ImageHandler class.
-Version: 0.1.6
-"""
-
-from __future__ import annotations
-
-import logging
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class ImageUtils:
-    """Image Utils Class for Valetudo Hypfer Image Handler.
-    It is used to simplify the ImageHandler class."""
-
-    def __init__(self, image_handler):
-        self.img = image_handler
-        self.file_name = self.img.shared.file_name
-
-    def get_vacuum_points(self, rotation_angle: int) -> list[dict[str, int]]:
-        """Calculate the calibration points based on the rotation angle."""
-
-        # 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,
-            },  # Top-left corner 0
-            {
-                "x": self.img.crop_area[2] - self.img.offset_x,
-                "y": self.img.crop_area[1] + self.img.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,
-            },  # Bottom-right corner 2
-            {
-                "x": self.img.crop_area[0] + self.img.offset_x,
-                "y": self.img.crop_area[3] - self.img.offset_y,
-            },  # Bottom-left corner (optional)3
-        ]
-
-        # Rotate the vacuum points based on the rotation angle
-        if rotation_angle == 90:
-            vacuum_points = [
-                vacuum_points[1],
-                vacuum_points[2],
-                vacuum_points[3],
-                vacuum_points[0],
-            ]
-        elif rotation_angle == 180:
-            vacuum_points = [
-                vacuum_points[2],
-                vacuum_points[3],
-                vacuum_points[0],
-                vacuum_points[1],
-            ]
-        elif rotation_angle == 270:
-            vacuum_points = [
-                vacuum_points[3],
-                vacuum_points[0],
-                vacuum_points[1],
-                vacuum_points[2],
-            ]
-
-        return vacuum_points
-
-    def re_get_vacuum_points(self, rotation_angle: int) -> list[dict[str, int]]:
-        """Recalculate the calibration points based on the rotation angle.
-        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),
-            },  # 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),
-            },  # 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),
-            },  # 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),
-            },  # Bottom-left corner (optional)3
-        ]
-
-        # Rotate the vacuum points based on the rotation angle
-        if rotation_angle == 90:
-            vacuum_points = [
-                vacuum_points[1],
-                vacuum_points[2],
-                vacuum_points[3],
-                vacuum_points[0],
-            ]
-        elif rotation_angle == 180:
-            vacuum_points = [
-                vacuum_points[2],
-                vacuum_points[3],
-                vacuum_points[0],
-                vacuum_points[1],
-            ]
-        elif rotation_angle == 270:
-            vacuum_points = [
-                vacuum_points[3],
-                vacuum_points[0],
-                vacuum_points[1],
-                vacuum_points[2],
-            ]
-
-        return vacuum_points
-
-    def set_image_offset_ratio_1_1(
-        self, width: int, height: int, rand256: bool = False
-    ) -> None:
-        """Set the image offset ratio to 1:1."""
-
-        rotation = self.img.shared.image_rotate
-        if not rand256:
-            if rotation in [0, 180]:
-                self.img.offset_y = self.img.crop_img_size[0] - width
-                self.img.offset_x = (height - self.img.crop_img_size[1]) // 2
-            elif rotation in [90, 270]:
-                self.img.offset_y = width - self.img.crop_img_size[0]
-                self.img.offset_x = (self.img.crop_img_size[1] - height) // 2
-        else:
-            if rotation in [0, 180]:
-                self.img.offset_x = (width - self.img.crop_img_size[0]) // 2
-                self.img.offset_y = height - self.img.crop_img_size[1]
-            elif rotation in [90, 270]:
-                self.img.offset_y = (self.img.crop_img_size[0] - width) // 2
-                self.img.offset_x = self.img.crop_img_size[1] - height
-        _LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.img.offset_x,
-            self.img.offset_y,
-        )
-
-    def set_image_offset_ratio_2_1(
-        self, width: int, height: int, rand256: bool = False
-    ) -> None:
-        """Set the image offset ratio to 2:1."""
-
-        rotation = self.img.shared.image_rotate
-        if not rand256:
-            if rotation in [0, 180]:
-                self.img.offset_y = width - self.img.crop_img_size[0]
-                self.img.offset_x = height - self.img.crop_img_size[1]
-            elif rotation in [90, 270]:
-                self.img.offset_x = width - self.img.crop_img_size[0]
-                self.img.offset_y = height - self.img.crop_img_size[1]
-        else:
-            if rotation in [0, 180]:
-                self.img.offset_y = width - self.img.crop_img_size[0]
-                self.img.offset_x = height - self.img.crop_img_size[1]
-            elif rotation in [90, 270]:
-                self.img.offset_x = width - self.img.crop_img_size[0]
-                self.img.offset_y = height - self.img.crop_img_size[1]
-
-        _LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.img.offset_x,
-            self.img.offset_y,
-        )
-
-    def set_image_offset_ratio_3_2(
-        self, width: int, height: int, rand256: bool = False
-    ) -> None:
-        """Set the image offset ratio to 3:2."""
-
-        rotation = self.img.shared.image_rotate
-
-        if not rand256:
-            if rotation in [0, 180]:
-                self.img.offset_y = width - self.img.crop_img_size[0]
-                self.img.offset_x = ((height - self.img.crop_img_size[1]) // 2) - (
-                    self.img.crop_img_size[1] // 10
-                )
-            elif rotation in [90, 270]:
-                self.img.offset_y = (self.img.crop_img_size[0] - width) // 2
-                self.img.offset_x = (self.img.crop_img_size[1] - height) + (
-                    (height // 10) // 2
-                )
-        else:
-            if rotation in [0, 180]:
-                self.img.offset_x = (width - self.img.crop_img_size[0]) // 2
-                self.img.offset_y = height - self.img.crop_img_size[1]
-            elif rotation in [90, 270]:
-                self.img.offset_y = (self.img.crop_img_size[0] - width) // 2
-                self.img.offset_x = self.img.crop_img_size[1] - height
-
-        _LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.img.offset_x,
-            self.img.offset_y,
-        )
-
-    def set_image_offset_ratio_5_4(
-        self, width: int, height: int, rand256: bool = False
-    ) -> None:
-        """Set the image offset ratio to 5:4."""
-
-        rotation = self.img.shared.image_rotate
-        if not rand256:
-            if rotation in [0, 180]:
-                self.img.offset_x = ((width - self.img.crop_img_size[0]) // 2) - (
-                    self.img.crop_img_size[0] // 2
-                )
-                self.img.offset_y = (self.img.crop_img_size[1] - height) - (
-                    self.img.crop_img_size[1] // 2
-                )
-            elif rotation in [90, 270]:
-                self.img.offset_y = ((self.img.crop_img_size[0] - width) // 2) - 10
-                self.img.offset_x = (self.img.crop_img_size[1] - height) + (
-                    height // 10
-                )
-        else:
-            if rotation in [0, 180]:
-                self.img.offset_y = (width - self.img.crop_img_size[0]) // 2
-                self.img.offset_x = self.img.crop_img_size[1] - height
-            elif rotation in [90, 270]:
-                self.img.offset_y = (self.img.crop_img_size[0] - width) // 2
-                self.img.offset_x = self.img.crop_img_size[1] - height
-
-        _LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.img.offset_x,
-            self.img.offset_y,
-        )
-
-    def set_image_offset_ratio_9_16(
-        self, width: int, height: int, rand256: bool = False
-    ) -> None:
-        """Set the image offset ratio to 9:16."""
-
-        rotation = self.img.shared.image_rotate
-        if not rand256:
-            if rotation in [0, 180]:
-                self.img.offset_y = width - self.img.crop_img_size[0]
-                self.img.offset_x = height - self.img.crop_img_size[1]
-            elif rotation in [90, 270]:
-                self.img.offset_x = (width - self.img.crop_img_size[0]) + (height // 10)
-                self.img.offset_y = height - self.img.crop_img_size[1]
-        else:
-            if rotation in [0, 180]:
-                self.img.offset_y = width - self.img.crop_img_size[0]
-                self.img.offset_x = height - self.img.crop_img_size[1]
-            elif rotation in [90, 270]:
-                self.img.offset_x = width - self.img.crop_img_size[0]
-                self.img.offset_y = height - self.img.crop_img_size[1]
-
-        _LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.img.offset_x,
-            self.img.offset_y,
-        )
-
-    def set_image_offset_ratio_16_9(
-        self, width: int, height: int, rand256: bool = False
-    ) -> None:
-        """Set the image offset ratio to 16:9."""
-
-        rotation = self.img.shared.image_rotate
-        if not rand256:
-            if rotation in [0, 180]:
-                self.img.offset_y = width - self.img.crop_img_size[0]
-                self.img.offset_x = height - self.img.crop_img_size[1]
-            elif rotation in [90, 270]:
-                self.img.offset_x = width - self.img.crop_img_size[0]
-                self.img.offset_y = height - self.img.crop_img_size[1]
-        else:
-            if rotation in [0, 180]:
-                self.img.offset_y = width - self.img.crop_img_size[0]
-                self.img.offset_x = height - self.img.crop_img_size[1]
-            elif rotation in [90, 270]:
-                self.img.offset_x = width - self.img.crop_img_size[0]
-                self.img.offset_y = height - self.img.crop_img_size[1]
-
-        _LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.img.offset_x,
-            self.img.offset_y,
-        )
-
-    async def async_zone_propriety(self, zones_data) -> dict:
-        """Get the zone propriety"""
-        zone_properties = {}
-        id_count = 1
-        for zone in zones_data:
-            zone_name = zone.get("name")
-            coordinates = zone.get("coordinates")
-            if coordinates and len(coordinates) > 0:
-                coordinates[0].pop()
-                x1, y1, x2, y2 = coordinates[0]
-                zone_properties[zone_name] = {
-                    "zones": coordinates,
-                    "name": zone_name,
-                    "x": ((x1 + x2) // 2),
-                    "y": ((y1 + y2) // 2),
-                }
-                id_count += 1
-            if id_count > 1:
-                _LOGGER.debug("%s: Zones Properties updated.", self.file_name)
-        return zone_properties
-
-    async def async_points_propriety(self, points_data) -> dict:
-        """Get the point propriety"""
-        point_properties = {}
-        id_count = 1
-        for point in points_data:
-            point_name = point.get("name")
-            coordinates = point.get("coordinates")
-            if coordinates and len(coordinates) > 0:
-                coordinates = point.get("coordinates")
-                x1, y1 = coordinates
-                point_properties[id_count] = {
-                    "position": coordinates,
-                    "name": point_name,
-                    "x": x1,
-                    "y": y1,
-                }
-                id_count += 1
-            if id_count > 1:
-                _LOGGER.debug("%s: Point Properties updated.", self.file_name)
-        return point_properties