valetudo-map-parser 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

valetudo_map_parser/hypfer_handler.py

@@ -2,170 +2,126 @@
 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
+import asyncio
+import numpy as np
 
 from PIL import Image
 
+from .config.async_utils import AsyncNumPy, AsyncPIL
+from .config.auto_crop import AutoCrop
+from .config.drawable_elements import DrawableElement
+from .config.shared import CameraShared
+from .config.utils import pil_to_webp_bytes
 from .config.types import (
+    COLORS,
+    LOGGER,
     CalibrationPoints,
-    ChargerPosition,
-    ImageSize,
-    RobotPosition,
+    Colors,
     RoomsProperties,
+    RoomStore,
+    WebPBytes,
+    JsonType,
 )
-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,
+    numpy_to_webp_bytes,
+    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.img_work_layer = (
+            None  # persistent working buffer to avoid per-frame allocations
+        )
         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(
+                    {
+                        "id": room_id,
+                        "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,
-        m_json: json | None,
-    ) -> Image.Image | None:
+        m_json: JsonType | None,
+        return_webp: bool = False,
+    ) -> WebPBytes | Image.Image | None:
         """Get the image from the JSON data.
         It uses the ImageDraw class to draw some of the elements of the image.
         The robot itself will be drawn in this function as per some of the values are needed for other tasks.
         @param m_json: The JSON data to use to draw the image.
-        @return Image.Image: The image to display.
+        @param return_webp: If True, return WebP bytes; if False, return PIL Image (default).
+        @return WebPBytes | Image.Image: WebP bytes or PIL Image depending on return_webp parameter.
         """
         # 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,135 +146,285 @@ 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)
+                # Populate active_zones from the JSON data
+                self.active_zones = 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
+
+                            # Draw the layer ONLY if enabled
+                            is_wall_layer = layer_type == "wall"
+                            if is_wall_layer:
+                                # Skip walls entirely if disabled
+                                if not self.drawing_config.is_enabled(
+                                    DrawableElement.WALL
+                                ):
+                                    continue
+                            # 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,
+                            )
+
+                    # 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(
                             self.json_data
                         )
-                        if self.rooms_pos and robot_position and robot_position_angle:
-                            self.robot_pos = await self.imd.async_get_robot_in_room(
-                                robot_x=(robot_position[0]),
-                                robot_y=(robot_position[1]),
-                                angle=robot_position_angle,
-                            )
-                    _LOGGER.info("%s: Completed base Layers", self.file_name)
+
+                    # Ensure room data is available for robot room detection (even if not extracted above)
+                    if not self.rooms_pos and not self.room_propriety:
+                        self.room_propriety = await self.async_extract_room_properties(
+                            self.json_data
+                        )
+
+                    # Always check robot position for zooming (moved outside the condition)
+                    if self.rooms_pos and robot_position and robot_position_angle:
+                        self.robot_pos = await self.imd.async_get_robot_in_room(
+                            robot_x=(robot_position[0]),
+                            robot_y=(robot_position[1]),
+                            angle=robot_position_angle,
+                        )
+                    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)
-                # 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
+                # Ensure persistent working buffer exists and matches base (allocate only when needed)
+                if (
+                    self.img_work_layer is None
+                    or self.img_work_layer.shape != self.img_base_layer.shape
+                    or self.img_work_layer.dtype != self.img_base_layer.dtype
+                ):
+                    self.img_work_layer = np.empty_like(self.img_base_layer)
+
+                # Copy the base layer into the persistent working buffer (no new allocation per frame)
+                np.copyto(self.img_work_layer, self.img_base_layer)
+                img_np_array = self.img_work_layer
+
+                # Prepare parallel data extraction tasks
+                data_tasks = []
+
+                # Prepare zone data extraction
+                if self.drawing_config.is_enabled(DrawableElement.RESTRICTED_AREA):
+                    data_tasks.append(self._prepare_zone_data(m_json))
+
+                # Prepare go_to flag data extraction
+                if self.drawing_config.is_enabled(DrawableElement.GO_TO_TARGET):
+                    data_tasks.append(self._prepare_goto_data(entity_dict))
+
+                # Prepare path data extraction
+                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)
+                    data_tasks.append(self._prepare_path_data(m_json))
+
+                # Await all data preparation tasks if any were created
+                if data_tasks:
+                    await asyncio.gather(*data_tasks)
+
+                # Process drawing operations sequentially (since they modify the same array)
+                # Draw zones 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 paths if enabled
+                if path_enabled:
+                    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,
+                        )
+                # Synchronize zooming state from ImageDraw to handler before auto-crop
+                self.zooming = self.imd.img_h.zooming
+
                 # 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,
-                )
-                return resized_image
-            _LOGGER.debug("%s: Frame Completed.", self.file_name)
-            return pil_img
+            # Handle resizing if needed, then return based on format preference
+            if self.check_zoom_and_aspect_ratio():
+                # Convert to PIL for resizing
+                pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
+                del img_np_array
+                resize_params = prepare_resize_params(self, pil_img, False)
+                resized_image = await self.async_resize_images(resize_params)
+
+                # Return WebP bytes or PIL Image based on parameter
+                if return_webp:
+                    webp_bytes = await pil_to_webp_bytes(resized_image)
+                    return webp_bytes
+                else:
+                    return resized_image
+            else:
+                # Return WebP bytes or PIL Image based on parameter
+                if return_webp:
+                    # Convert directly from NumPy to WebP for better performance
+                    webp_bytes = await numpy_to_webp_bytes(img_np_array)
+                    del img_np_array
+                    LOGGER.debug("%s: Frame Completed.", self.file_name)
+                    return webp_bytes
+                else:
+                    # Convert to PIL Image (original behavior)
+                    pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
+                    del img_np_array
+                    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 +432,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 +451,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 +465,61 @@ 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),
+        )
 
-        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
+    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,
+        )
+
+    @staticmethod
+    async def async_copy_array(original_array):
+        """Copy the array."""
+        return await AsyncNumPy.async_copy(original_array)
+
+    async def _prepare_zone_data(self, m_json):
+        """Prepare zone data for parallel processing."""
+        await asyncio.sleep(0)  # Yield control
+        try:
+            return self.data.find_zone_entities(m_json)
+        except (ValueError, KeyError):
+            return None
+
+    @staticmethod
+    async def _prepare_goto_data(entity_dict):
+        """Prepare go-to flag data for parallel processing."""
+        await asyncio.sleep(0)  # Yield control
+        # Extract go-to target data from entity_dict
+        return entity_dict.get("go_to_target", None)
+
+    async def _prepare_path_data(self, m_json):
+        """Prepare path data for parallel processing."""
+        await asyncio.sleep(0)  # Yield control
+        try:
+            return self.data.find_paths_entities(m_json)
+        except (ValueError, KeyError):
+            return None