valetudo-map-parser 0.1.8__py3-none-any.whl → 0.1.9a1__py3-none-any.whl

valetudo_map_parser/hypfer_handler.py

@@ -2,153 +2,92 @@
 Hypfer Image Handler Class.
 It returns the PIL PNG image frame relative to the Map Data extrapolated from the vacuum json.
 It also returns calibration, rooms data to the card and other images information to the camera.
-Version: 2024.08.0
+Version: 0.1.9
 """
 
 from __future__ import annotations
 
 import json
-import logging
 
 from PIL import Image
 
+from .config.auto_crop import AutoCrop
+from .config.drawable_elements import DrawableElement
+from .config.shared import CameraShared
 from .config.types import (
+    COLORS,
+    LOGGER,
     CalibrationPoints,
-    ChargerPosition,
-    ImageSize,
-    RobotPosition,
+    Colors,
     RoomsProperties,
+    RoomStore,
 )
-from .config.auto_crop import AutoCrop
-from .config.drawable import Drawable
-from .config.shared import CameraShared
-from .map_data import ImageData
-from .images_utils import (
-    ImageUtils as ImUtils,
-    resize_to_aspect_ratio,
-)
-from .hypfer_draw import (
-    ImageDraw as ImDraw,
+from .config.utils import (
+    BaseHandler,
+    initialize_drawing_config,
+    manage_drawable_elements,
+    prepare_resize_params,
 )
-from .config.colors import ColorsManagment, SupportedColor
-
-_LOGGER = logging.getLogger(__name__)
+from .hypfer_draw import ImageDraw as ImDraw
+from .map_data import ImageData
+from .rooms_handler import RoomsHandler
 
 
-class HypferMapImageHandler:
+class HypferMapImageHandler(BaseHandler, AutoCrop):
     """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."""
+        BaseHandler.__init__(self)
         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.
+        AutoCrop.__init__(self, self)
         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
+
+        # Initialize drawing configuration using the shared utility function
+        self.drawing_config, self.draw, self.enhanced_draw = initialize_drawing_config(
+            self
+        )
+
         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.
-        self.trim_left = 0  # memory stored trims calculated once.
-        self.trim_right = 0  # memory stored trims calculated once.
-        self.trim_up = 0  # memory stored trims calculated once.
-        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.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.imd = ImDraw(self)  # Image Draw class.
         self.color_grey = (128, 128, 128, 255)
+        self.file_name = self.shared.file_name  # file name of the vacuum.
+        self.rooms_handler = RoomsHandler(
+            self.file_name, self.drawing_config
+        )  # Room data handler
+
+    @staticmethod
+    def get_corners(x_max, x_min, y_max, y_min):
+        """Get the corners of the room."""
+        return [(x_min, y_min), (x_max, y_min), (x_max, y_max), (x_min, y_max)]
 
     async def async_extract_room_properties(self, json_data) -> RoomsProperties:
         """Extract room properties from the JSON data."""
-
-        room_properties = {}
-        self.rooms_pos = []
-        pixel_size = json_data.get("pixelSize", [])
-
-        for layer in json_data.get("layers", []):
-            if layer["__class"] == "MapLayer":
-                meta_data = layer.get("metaData", {})
-                segment_id = meta_data.get("segmentId")
-                if segment_id is not None:
-                    name = meta_data.get("name")
-                    compressed_pixels = layer.get("compressedPixels", [])
-                    pixels = self.data.sublist(compressed_pixels, 3)
-                    # Calculate x and y min/max from compressed pixels
-                    (
-                        x_min,
-                        y_min,
-                        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),
-                    ]
-                    room_id = str(segment_id)
-                    self.rooms_pos.append(
-                        {
-                            "name": name,
-                            "corners": corners,
-                        }
-                    )
-                    room_properties[room_id] = {
-                        "number": segment_id,
-                        "outline": corners,
-                        "name": name,
-                        "x": ((x_min + x_max) // 2),
-                        "y": ((y_min + y_max) // 2),
-                    }
+        room_properties = await self.rooms_handler.async_extract_room_properties(
+            json_data
+        )
         if room_properties:
-            _LOGGER.debug("%s: Rooms data extracted!", self.file_name)
+            rooms = RoomStore(self.file_name, room_properties)
+            LOGGER.debug(
+                "%s: Rooms data extracted! %s", self.file_name, rooms.get_rooms()
+            )
+            # Convert room_properties to the format expected by async_get_robot_in_room
+            self.rooms_pos = []
+            for room_id, room_data in room_properties.items():
+                self.rooms_pos.append(
+                    {"name": room_data["name"], "outline": room_data["outline"]}
+                )
         else:
-            _LOGGER.debug("%s: Rooms data not available!", self.file_name)
+            LOGGER.debug("%s: Rooms data not available!", self.file_name)
             self.rooms_pos = None
         return room_properties
 
-    async def _async_initialize_colors(self):
-        """Initialize and return all required colors."""
-        return {
-            "color_wall": self.colors_manager.get_colour(SupportedColor.WALLS),
-            "color_no_go": self.colors_manager.get_colour(SupportedColor.NO_GO),
-            "color_go_to": self.colors_manager.get_colour(SupportedColor.GO_TO),
-            "color_robot": self.colors_manager.get_colour(SupportedColor.ROBOT),
-            "color_charger": self.colors_manager.get_colour(SupportedColor.CHARGER),
-            "color_move": self.colors_manager.get_colour(SupportedColor.PATH),
-            "color_background": self.colors_manager.get_colour(
-                SupportedColor.MAP_BACKGROUND
-            ),
-            "color_zone_clean": self.colors_manager.get_colour(
-                SupportedColor.ZONE_CLEAN
-            ),
-        }
-
     # noinspection PyUnresolvedReferences,PyUnboundLocalVariable
     async def async_get_image_from_json(
         self,
@@ -161,11 +100,13 @@ 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:
-                _LOGGER.debug("%s: Creating Image.", self.file_name)
+                LOGGER.debug("%s: Creating Image.", self.file_name)
                 # buffer json data
                 self.json_data = m_json
                 # Get the image size from the JSON data
@@ -190,35 +131,120 @@ 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
+                    # Create 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():
-                        room_id, img_np_array = await self.imd.async_draw_base_layer(
-                            img_np_array,
-                            compressed_pixels_list,
-                            layer_type,
-                            colors["color_wall"],
-                            colors["color_zone_clean"],
-                            pixel_size,
+                    # Draw layers and segments if enabled
+                    room_id = 0
+                    # Keep track of disabled rooms to skip their walls later
+                    disabled_rooms = set()
+
+                    if self.drawing_config.is_enabled(DrawableElement.FLOOR):
+                        # First pass: identify disabled rooms
+                        for layer_type, compressed_pixels_list in layers.items():
+                            # Check if this is a room layer
+                            if layer_type == "segment":
+                                # The room_id is the current room being processed (0-based index)
+                                # We need to check if ROOM_{room_id+1} is enabled (1-based in DrawableElement)
+                                current_room_id = room_id + 1
+                                if 1 <= current_room_id <= 15:
+                                    room_element = getattr(
+                                        DrawableElement, f"ROOM_{current_room_id}", None
+                                    )
+                                    if (
+                                        room_element
+                                        and not self.drawing_config.is_enabled(
+                                            room_element
+                                        )
+                                    ):
+                                        # Add this room to the disabled rooms set
+                                        disabled_rooms.add(room_id)
+                                        LOGGER.debug(
+                                            "%s: Room %d is disabled and will be skipped",
+                                            self.file_name,
+                                            current_room_id,
+                                        )
+                                room_id = (
+                                    room_id + 1
+                                ) % 16  # Cycle room_id back to 0 after 15
+
+                        # Reset room_id for the actual drawing pass
+                        room_id = 0
+
+                        # Second pass: draw enabled rooms and walls
+                        for layer_type, compressed_pixels_list in layers.items():
+                            # Check if this is a room layer
+                            is_room_layer = layer_type == "segment"
+
+                            # If it's a room layer, check if the specific room is enabled
+                            if is_room_layer:
+                                # The room_id is the current room being processed (0-based index)
+                                # We need to check if ROOM_{room_id+1} is enabled (1-based in DrawableElement)
+                                current_room_id = room_id + 1
+                                if 1 <= current_room_id <= 15:
+                                    room_element = getattr(
+                                        DrawableElement, f"ROOM_{current_room_id}", None
+                                    )
+
+                                    # Skip this room if it's disabled
+                                    if not self.drawing_config.is_enabled(room_element):
+                                        room_id = (
+                                            room_id + 1
+                                        ) % 16  # Increment room_id even if we skip
+                                        continue
+
+                            # Check if this is a wall layer and if walls are enabled
+                            is_wall_layer = layer_type == "wall"
+                            if is_wall_layer:
+                                if not self.drawing_config.is_enabled(
+                                    DrawableElement.WALL
+                                ):
+                                    pass
+
+                            # Draw the layer
+                            (
+                                room_id,
+                                img_np_array,
+                            ) = await self.imd.async_draw_base_layer(
+                                img_np_array,
+                                compressed_pixels_list,
+                                layer_type,
+                                colors["wall"],
+                                colors["zone_clean"],
+                                pixel_size,
+                                disabled_rooms if layer_type == "wall" else None,
+                            )
+
+                            # Update element map for this layer
+                            if is_room_layer and 0 < room_id <= 15:
+                                # Mark the room in the element map
+                                room_element = getattr(
+                                    DrawableElement, f"ROOM_{room_id}", None
+                                )
+
+                    # Draw the virtual walls if enabled
+                    if self.drawing_config.is_enabled(DrawableElement.VIRTUAL_WALL):
+                        img_np_array = await self.imd.async_draw_virtual_walls(
+                            m_json, img_np_array, colors["no_go"]
                         )
-                    # 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"]
-                    )
-                    # Draw charger.
-                    img_np_array = await self.imd.async_draw_charger(
-                        img_np_array, entity_dict, colors["color_charger"]
-                    )
-                    # Draw obstacles if any.
-                    img_np_array = await self.imd.async_draw_obstacle(
-                        img_np_array, entity_dict, colors["color_no_go"]
-                    )
+
+                    # Draw charger if enabled
+                    if self.drawing_config.is_enabled(DrawableElement.CHARGER):
+                        img_np_array = await self.imd.async_draw_charger(
+                            img_np_array, entity_dict, colors["charger"]
+                        )
+
+                    # Draw obstacles if enabled
+                    if self.drawing_config.is_enabled(DrawableElement.OBSTACLE):
+                        self.shared.obstacles_pos = self.data.get_obstacles(entity_dict)
+                        if self.shared.obstacles_pos:
+                            img_np_array = await self.imd.async_draw_obstacle(
+                                img_np_array,  self.shared.obstacles_pos, colors["no_go"]
+                            )
                     # Robot and rooms position
                     if (room_id > 0) and not self.room_propriety:
                         self.room_propriety = await self.async_extract_room_properties(
@@ -230,95 +256,109 @@ class HypferMapImageHandler:
                                 robot_y=(robot_position[1]),
                                 angle=robot_position_angle,
                             )
-                    _LOGGER.info("%s: Completed base Layers", self.file_name)
+                    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 (
                     new_frame_hash != self.img_hash
                 ):
                     self.frame_number = 0
-                _LOGGER.debug(
+                LOGGER.debug(
                     "%s: %s at Frame Number: %s",
                     self.file_name,
                     str(self.json_id),
                     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(
-                    m_json,
-                    img_np_array,
-                    colors["color_zone_clean"],
-                    colors["color_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"]
-                )
-                # 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
+                # Draw zones if any and if enabled
+                if self.drawing_config.is_enabled(DrawableElement.RESTRICTED_AREA):
+                    img_np_array = await self.imd.async_draw_zones(
+                        m_json,
+                        img_np_array,
+                        colors["zone_clean"],
+                        colors["no_go"],
+                    )
+
+                # Draw the go_to target flag if enabled
+                if self.drawing_config.is_enabled(DrawableElement.GO_TO_TARGET):
+                    img_np_array = await self.imd.draw_go_to_flag(
+                        img_np_array, entity_dict, colors["go_to"]
+                    )
+
+                # Draw path prediction and paths if enabled
+                path_enabled = self.drawing_config.is_enabled(DrawableElement.PATH)
+                LOGGER.info(
+                    "%s: PATH element enabled: %s", self.file_name, path_enabled
                 )
+                if path_enabled:
+                    LOGGER.info("%s: Drawing path", self.file_name)
+                    img_np_array = await self.imd.async_draw_paths(
+                        img_np_array, m_json, colors["move"], self.color_grey
+                    )
+                else:
+                    LOGGER.info("%s: Skipping path drawing", self.file_name)
+
                 # Check if the robot is docked.
                 if self.shared.vacuum_state == "docked":
                     # Adjust the robot angle.
                     robot_position_angle -= 180
 
-                if robot_pos:
+                # Draw the robot if enabled
+                if robot_pos and self.drawing_config.is_enabled(DrawableElement.ROBOT):
+                    # Get robot color (allows for customization)
+                    robot_color = self.drawing_config.get_property(
+                        DrawableElement.ROBOT, "color", colors["robot"]
+                    )
+
                     # Draw the robot
                     img_np_array = await self.draw.robot(
                         layers=img_np_array,
                         x=robot_position[0],
                         y=robot_position[1],
                         angle=robot_position_angle,
-                        fill=colors["color_robot"],
+                        fill=robot_color,
                         robot_state=self.shared.vacuum_state,
                     )
+
+                    # Update element map for robot position
+                    if (
+                        hasattr(self.shared, "element_map")
+                        and self.shared.element_map is not None
+                    ):
+                        update_element_map_with_robot(
+                            self.shared.element_map,
+                            robot_position,
+                            DrawableElement.ROBOT,
+                        )
                 # Resize the image
-                img_np_array = await self.ac.async_auto_trim_and_zoom_image(
+                img_np_array = await self.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,
                 )
             # If the image is None return None and log the error.
             if img_np_array is None:
-                _LOGGER.warning("%s: Image array is None.", self.file_name)
+                LOGGER.warning("%s: Image array is None.", self.file_name)
                 return None
 
             # Convert the numpy array to a PIL image
             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
-                (
-                    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,
-                )
+            if self.check_zoom_and_aspect_ratio():
+                resize_params = prepare_resize_params(self, pil_img, False)
+                resized_image = await self.async_resize_images(resize_params)
                 return resized_image
-            _LOGGER.debug("%s: Frame Completed.", self.file_name)
+            LOGGER.debug("%s: Frame Completed.", self.file_name)
             return pil_img
         except (RuntimeError, RuntimeWarning) as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "%s: Error %s during image creation.",
                 self.file_name,
                 str(e),
@@ -326,38 +366,18 @@ 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."""
         if self.room_propriety:
             return self.room_propriety
         if self.json_data:
-            _LOGGER.debug("Checking %s Rooms data..", self.file_name)
+            LOGGER.debug("Checking %s Rooms data..", self.file_name)
             self.room_propriety = await self.async_extract_room_properties(
                 self.json_data
             )
             if self.room_propriety:
-                _LOGGER.debug("Got %s Rooms Attributes.", self.file_name)
+                LOGGER.debug("Got %s Rooms Attributes.", self.file_name)
         return self.room_propriety
 
     def get_calibration_data(self) -> CalibrationPoints:
@@ -365,20 +385,12 @@ class HypferMapImageHandler:
         this will create the attribute calibration points."""
         calibration_data = []
         rotation_angle = self.shared.image_rotate
-        _LOGGER.info("Getting %s Calibrations points.", self.file_name)
+        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)
+        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):
@@ -387,32 +399,38 @@ class HypferMapImageHandler:
         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
-        """
+    # Element selection methods
+    def enable_element(self, element_code: DrawableElement) -> None:
+        """Enable drawing of a specific element."""
+        self.drawing_config.enable_element(element_code)
+        LOGGER.info(
+            "%s: Enabled element %s, now enabled: %s",
+            self.file_name,
+            element_code.name,
+            self.drawing_config.is_enabled(element_code),
+        )
+
+    def disable_element(self, element_code: DrawableElement) -> None:
+        """Disable drawing of a specific element."""
+        manage_drawable_elements(self, "disable", element_code=element_code)
+
+    def set_elements(self, element_codes: list[DrawableElement]) -> None:
+        """Enable only the specified elements, disable all others."""
+        manage_drawable_elements(self, "set_elements", element_codes=element_codes)
+
+    def set_element_property(
+        self, element_code: DrawableElement, property_name: str, value
+    ) -> None:
+        """Set a drawing property for an element."""
+        manage_drawable_elements(
+            self,
+            "set_property",
+            element_code=element_code,
+            property_name=property_name,
+            value=value,
+        )
 
-        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
+    @staticmethod
+    async def async_copy_array(original_array):
+        """Copy the array."""
+        return original_array.copy()