valetudo-map-parser 0.1.9b45__py3-none-any.whl → 0.1.9b47__py3-none-any.whl

valetudo_map_parser/hypfer_handler.py

@@ -63,15 +63,15 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         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.element_map_manager = OptimizedElementMapGenerator(self.drawing_config,
-                                                       self.shared)  # Map of element codes
+        self.element_map_manager = OptimizedElementMapGenerator(
+            self.drawing_config, self.shared
+        )  # Map of element codes
 
     @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 extract_room_outline_from_map(self, room_id_int, pixels, pixel_size):
         """Extract the outline of a room using the pixel data and element map.
 
@@ -232,7 +232,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                         size_x, size_y, colors["background"]
                     )
 
-
                     LOGGER.info("%s: Drawing map with color blending", self.file_name)
 
                     # Draw layers and segments if enabled
@@ -451,9 +450,14 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     )
 
                     # Update element map for robot position
-                    if hasattr(self.shared, 'element_map') and self.shared.element_map is not None:
+                    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
+                            self.shared.element_map,
+                            robot_position,
+                            DrawableElement.ROBOT,
                         )
                 # Resize the image
                 img_np_array = await self.async_auto_trim_and_zoom_image(
@@ -468,21 +472,35 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 LOGGER.warning("%s: Image array is None.", self.file_name)
                 return None
             # Debug logging for element map creation
-            LOGGER.info("%s: Frame number: %d, has element_map: %s",
-                       self.file_name, self.frame_number, hasattr(self.shared, 'element_map'))
+            LOGGER.info(
+                "%s: Frame number: %d, has element_map: %s",
+                self.file_name,
+                self.frame_number,
+                hasattr(self.shared, "element_map"),
+            )
 
             if (self.shared.element_map is None) and (self.frame_number == 1):
                 # Create element map for tracking what's drawn where
-                LOGGER.info("%s: Creating element map with shape: %s",
-                           self.file_name, img_np_array.shape)
+                LOGGER.info(
+                    "%s: Creating element map with shape: %s",
+                    self.file_name,
+                    img_np_array.shape,
+                )
 
                 # Generate the element map directly from JSON data
                 # This will create a cropped element map containing only the non-zero elements
                 LOGGER.info("%s: Generating element map from JSON data", self.file_name)
-                self.shared.element_map = await self.element_map_manager.async_generate_from_json(m_json)
+                self.shared.element_map = (
+                    await self.element_map_manager.async_generate_from_json(m_json)
+                )
 
-                LOGGER.info("%s: Element map created with shape: %s",
-                           self.file_name, self.shared.element_map.shape if self.shared.element_map is not None else None)
+                LOGGER.info(
+                    "%s: Element map created with shape: %s",
+                    self.file_name,
+                    self.shared.element_map.shape
+                    if self.shared.element_map is not None
+                    else None,
+                )
             # Convert the numpy array to a PIL image
             pil_img = Image.fromarray(img_np_array, mode="RGBA")
             del img_np_array
@@ -573,7 +591,9 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
 
     def get_room_at_position(self, x: int, y: int) -> int | None:
         """Get the room ID at a specific position, or None if not a room."""
-        return get_room_at_position(self.shared.element_map, x, y, DrawableElement.ROOM_1)
+        return get_room_at_position(
+            self.shared.element_map, x, y, DrawableElement.ROOM_1
+        )
 
     @staticmethod
     async def async_copy_array(original_array):

valetudo_map_parser/map_data.py

@@ -3,7 +3,7 @@ Collections of Json and List routines
 ImageData is part of the Image_Handler
 used functions to search data in the json
 provided for the creation of the new camera frame
-Version: v0.1.9.b42
+Version: v0.1.6
 """
 
 from __future__ import annotations

valetudo_map_parser/rand25_handler.py

@@ -31,7 +31,6 @@ from .config.utils import (
     BaseHandler,
     get_element_at_position,
     get_room_at_position,
-    handle_room_outline_error,
     initialize_drawing_config,
     manage_drawable_elements,
     prepare_resize_params,
@@ -130,7 +129,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
     async def extract_room_properties(
         self, json_data: JsonType, destinations: JsonType
-    ) -> tuple[RoomsProperties, Any, Any]:
+    ) -> RoomsProperties:
         """Extract the room properties."""
         unsorted_id = RandImageData.get_rrm_segments_ids(json_data)
         size_x, size_y = RandImageData.get_rrm_image_size(json_data)
@@ -150,88 +149,62 @@ class ReImageHandler(BaseHandler, AutoCrop):
             room_id_to_data = {room["id"]: room for room in room_data}
             self.rooms_pos = []
             room_properties = {}
-            if not self.outlines:
-                # Return empty data if no outlines are available
-                _LOGGER.debug("%s: No outlines available", self.file_name)
-                return None, None, None  # Return empty data for all three return values
-
-            # If we have outlines, proceed with processing
-            for id_x, room_id in enumerate(unsorted_id):
-                if room_id in room_id_to_data:
-                    room_info = room_id_to_data[room_id]
-                    name = room_info.get("name")
-                    # Calculate x and y min/max from outlines
-                    x_min = self.outlines[id_x][0][0]
-                    x_max = self.outlines[id_x][1][0]
-                    y_min = self.outlines[id_x][0][1]
-                    y_max = self.outlines[id_x][1][1]
-
-                    # Get rectangular corners as a fallback
-                    corners = self.get_corners(x_max, x_min, y_max, y_min)
-
-                    # Try to extract a more accurate room outline from the element map
-                    try:
-                        # Extract the room outline using the element map
-                        outline = await self.extract_room_outline_from_map(
-                            room_id, self.segment_data[id_x]
+            if self.outlines:
+                for id_x, room_id in enumerate(unsorted_id):
+                    if room_id in room_id_to_data:
+                        room_info = room_id_to_data[room_id]
+                        name = room_info.get("name")
+                        # Calculate x and y min/max from outlines
+                        x_min = self.outlines[id_x][0][0]
+                        x_max = self.outlines[id_x][1][0]
+                        y_min = self.outlines[id_x][0][1]
+                        y_max = self.outlines[id_x][1][1]
+                        corners = self.get_corners(x_max, x_min, y_max, y_min)
+                        # rand256 vacuums accept int(room_id) or str(name)
+                        # the card will soon support int(room_id) but the camera will send name
+                        # this avoids the manual change of the values in the card.
+                        self.rooms_pos.append(
+                            {
+                                "name": name,
+                                "corners": corners,
+                            }
                         )
-                        _LOGGER.debug(
-                            "%s: Traced outline for room %s with %d points",
-                            self.file_name,
-                            room_id,
-                            len(outline),
-                        )
-                    except (
-                        ValueError,
-                        IndexError,
-                        TypeError,
-                        ArithmeticError,
-                    ) as e:
-                        handle_room_outline_error(self.file_name, room_id, e)
-                        outline = corners
-
-                    # rand256 vacuums accept int(room_id) or str(name)
-                    # the card will soon support int(room_id) but the camera will send name
-                    # this avoids the manual change of the values in the card.
-                    self.rooms_pos.append(
-                        {
+                        room_properties[int(room_id)] = {
+                            "number": int(room_id),
+                            "outline": corners,
                             "name": name,
-                            "corners": corners,
+                            "x": (x_min + x_max) // 2,
+                            "y": (y_min + y_max) // 2,
                         }
+                # get the zones and points data
+                zone_properties = await self.async_zone_propriety(zones_data)
+                # get the 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,
+                        f"{len(zone_properties)} Zones" if zone_properties else None,
+                    ]
+                    extracted_data = ", ".join(filter(None, extracted_data))
+                    _LOGGER.debug("Extracted data: %s", extracted_data)
+                else:
+                    self.rooms_pos = None
+                    _LOGGER.debug(
+                        "%s: Rooms and Zones data not available!", self.file_name
                     )
-                    room_properties[int(room_id)] = {
-                        "number": int(room_id),
-                        "outline": outline,
-                        "name": name,
-                        "x": (x_min + x_max) // 2,
-                        "y": (y_min + y_max) // 2,
-                    }
-            # get the zones and points data
-            zone_properties = await self.async_zone_propriety(zones_data)
-            # get the 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,
-                    f"{len(zone_properties)} Zones" if zone_properties else None,
-                ]
-                extracted_data = ", ".join(filter(None, extracted_data))
-                _LOGGER.debug("Extracted data: %s", extracted_data)
+                rooms = RoomStore(self.file_name, room_properties)
+                _LOGGER.debug("Rooms Data: %s", rooms.get_rooms())
+                return room_properties, zone_properties, point_properties
             else:
-                self.rooms_pos = None
-                _LOGGER.debug(
-                    "%s: Rooms and Zones data not available!", self.file_name
-                )
-            rooms = RoomStore(self.file_name, room_properties)
-            _LOGGER.debug("Rooms Data: %s", rooms.get_rooms())
-            return room_properties, zone_properties, point_properties
+                _LOGGER.debug("%s: No outlines available", self.file_name)
+                return None, None, None
         except (RuntimeError, ValueError) as e:
             _LOGGER.debug(
                 "No rooms Data or Error in extract_room_properties: %s",
                 e,
                 exc_info=True,
             )
-            return None, None, None  # Return empty data in case of error
+            return None, None, None
 
     async def get_image_from_rrm(
         self,
@@ -475,12 +448,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
         # If no rooms data is available, return a default position
         if not self.rooms_pos:
             _LOGGER.debug("%s: No rooms data available", self.file_name)
-            return {
-                "x": robot_x,
-                "y": robot_y,
-                "angle": angle,
-                "in_room": "unknown"
-            }
+            return {"x": robot_x, "y": robot_y, "angle": angle, "in_room": "unknown"}
 
         # If rooms data is available, search for the room
         if self.robot_in_room:
@@ -504,9 +472,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     "angle": angle,
                     "in_room": self.robot_in_room["room"],
                 }
-                _LOGGER.debug(
-                    "%s is in %s", self.file_name, self.robot_in_room["room"]
-                )
+                _LOGGER.debug("%s is in %s", self.file_name, self.robot_in_room["room"])
                 del room, corners, robot_x, robot_y  # free memory.
                 return temp
         # After checking all rooms and not finding a match
@@ -586,8 +552,16 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
         charger_radius = 15
         # Handle both dictionary format {'x': x, 'y': y} and list format [x, y]
-        charger_x = self.charger_pos.get('x') if isinstance(self.charger_pos, dict) else self.charger_pos[0]
-        charger_y = self.charger_pos.get('y') if isinstance(self.charger_pos, dict) else self.charger_pos[1]
+        charger_x = (
+            self.charger_pos.get("x")
+            if isinstance(self.charger_pos, dict)
+            else self.charger_pos[0]
+        )
+        charger_y = (
+            self.charger_pos.get("y")
+            if isinstance(self.charger_pos, dict)
+            else self.charger_pos[1]
+        )
 
         for dy in range(-charger_radius, charger_radius + 1):
             for dx in range(-charger_radius, charger_radius + 1):
@@ -595,5 +569,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 if dx * dx + dy * dy <= charger_radius * charger_radius:
                     cx, cy = int(charger_x + dx), int(charger_y + dy)
                     # Check if the coordinates are within the element map bounds
-                    if (0 <= cy < self.element_map.shape[0] and 0 <= cx < self.element_map.shape[1]):
+                    if (0 <= cy < self.element_map.shape[0]) and (
+                        0 <= cx < self.element_map.shape[1]
+                    ):
                         self.element_map[cy, cx] = DrawableElement.CHARGER

valetudo_map_parser/utils/color_utils.py

@@ -12,16 +12,16 @@ def get_blended_color(
     x: int,
     y: int,
     new_element: DrawableElement,
-    new_color: Tuple[int, int, int, int]
+    new_color: Tuple[int, int, int, int],
 ) -> Tuple[int, int, int, int]:
     """
     Get a blended color for a pixel based on the current element map and the new element to draw.
-    
+
     This function:
     1. Gets the current element at position (x,y) from the element map
     2. Gets the color for that element from the colors manager
     3. Blends the new color with the existing color based on alpha values
-    
+
     Args:
         element_map_generator: The element map generator containing the current element map
         colors_manager: The colors manager to get colors for elements
@@ -29,20 +29,20 @@ def get_blended_color(
         y: Y coordinate in the element map
         new_element: The new element to draw at this position
         new_color: The RGBA color of the new element
-        
+
     Returns:
         Blended RGBA color to use for drawing
     """
     # Get current element at this position
     current_element = element_map_generator.get_element_at_position(x, y)
-    
+
     # If no current element or it's the same as the new element, just return the new color
     if current_element is None or current_element == new_element:
         return new_color
-    
+
     # Get color for the current element
     current_color = None
-    
+
     # Handle different element types
     if current_element == DrawableElement.FLOOR:
         # Floor is the background color
@@ -57,6 +57,6 @@ def get_blended_color(
     else:
         # Default for unknown elements
         current_color = (100, 100, 100, 255)
-    
+
     # Blend the colors
     return colors_manager.blend_colors(current_color, new_color)

{valetudo_map_parser-0.1.9b45.dist-info → valetudo_map_parser-0.1.9b47.dist-info}/METADATA

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

@@ -0,0 +1,26 @@
+valetudo_map_parser/__init__.py,sha256=SOxmq7LkS7eMa2N4atW7ZBbqhGEL7fpj6MsyXZpCMsk,958
+valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
+valetudo_map_parser/config/auto_crop.py,sha256=6OvRsWzXMXBaSEvgwpaaisNdozDKiDyTmPjknFxoUMc,12624
+valetudo_map_parser/config/colors.py,sha256=zF-6CGe6XA9wtnrWY8hBmqsMNOcL1x5tZY1G6evniQ0,30278
+valetudo_map_parser/config/drawable.py,sha256=dZ6FZVch9GVIpT4k52I5iXWtSH9oD9KJArcK48p-OaA,23667
+valetudo_map_parser/config/drawable_elements.py,sha256=Ulfgf8B4LuLCfx-FfmC7LrP8o9ll_Sncg9mR774_3KE,43140
+valetudo_map_parser/config/enhanced_drawable.py,sha256=xNgFUNccstP245VgLFEA9gjB3-VvlSAJSjRgSZ3YFL0,16641
+valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
+valetudo_map_parser/config/rand25_parser.py,sha256=kIayyqVZBfQfAMkiArzqrrj9vqZB3pkgT0Y5ufrQmGA,16448
+valetudo_map_parser/config/room_outline.py,sha256=D20D-yeyKnlmVbW9lI7bsPtQGn2XkcWow6YNOEPnWVg,4800
+valetudo_map_parser/config/shared.py,sha256=WSl5rYSiTqE6YGAiwi9RILMZIQdFZRzVS8DwqzTZBbw,11309
+valetudo_map_parser/config/types.py,sha256=uEJY-yYHHJWW3EZjg7hERSFrC2XuKzzRGT3C0z31Aw0,18359
+valetudo_map_parser/config/utils.py,sha256=MP5_s9VFSdDERymujvDuGB8nYCXVuJcqg5tR5H9HCgY,33167
+valetudo_map_parser/hypfer_draw.py,sha256=oL_RbX0LEcPvOlMrfBA38qpJkMqqVwR-oAEbZeHqLWM,19898
+valetudo_map_parser/hypfer_handler.py,sha256=-nwGlfd-fqmNAHEeQFgCarr1t5v8gJTvb2ngDz_8PbM,27616
+valetudo_map_parser/map_data.py,sha256=lSKD-CG-RENOcNUDnUIIpqh74DuGnLmrH46IF1_EjwQ,19117
+valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valetudo_map_parser/rand25_handler.py,sha256=F9o1J6JZRV3CZTS4CG3AHNHZweKRM0nzd4HLmdPZe4w,23617
+valetudo_map_parser/reimg_draw.py,sha256=1q8LkNTPHEA9Tsapc_JnVw51kpPYNhaBU-KmHkefCQY,12507
+valetudo_map_parser/utils/__init__.py,sha256=r-GKKSPqBkMDd2K-vWe7kAix8OBrGN5HXC1RS2tbDwo,130
+valetudo_map_parser/utils/color_utils.py,sha256=VogvNcITQHvtMUrVkzKcimvKtwSw0fjH72_RWtNoULA,2394
+valetudo_map_parser-0.1.9b47.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b47.dist-info/METADATA,sha256=g31rBswTXn4z29eDmjywfBptpTAohQis8e6VKI8xQXA,3321
+valetudo_map_parser-0.1.9b47.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b47.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+valetudo_map_parser-0.1.9b47.dist-info/RECORD,,

valetudo_map_parser/config/colors_man.py

@@ -1,249 +0,0 @@
-"""
-Colors RGBA
-Version: v2025.02.0
-"""
-
-import logging
-
-from .types import (
-    ALPHA_BACKGROUND,
-    ALPHA_CHARGER,
-    ALPHA_GO_TO,
-    ALPHA_MOVE,
-    ALPHA_NO_GO,
-    ALPHA_ROBOT,
-    ALPHA_ROOM_0,
-    ALPHA_ROOM_1,
-    ALPHA_ROOM_2,
-    ALPHA_ROOM_3,
-    ALPHA_ROOM_4,
-    ALPHA_ROOM_5,
-    ALPHA_ROOM_6,
-    ALPHA_ROOM_7,
-    ALPHA_ROOM_8,
-    ALPHA_ROOM_9,
-    ALPHA_ROOM_10,
-    ALPHA_ROOM_11,
-    ALPHA_ROOM_12,
-    ALPHA_ROOM_13,
-    ALPHA_ROOM_14,
-    ALPHA_ROOM_15,
-    ALPHA_TEXT,
-    ALPHA_WALL,
-    ALPHA_ZONE_CLEAN,
-    COLOR_BACKGROUND,
-    COLOR_CHARGER,
-    COLOR_GO_TO,
-    COLOR_MOVE,
-    COLOR_NO_GO,
-    COLOR_ROBOT,
-    COLOR_ROOM_0,
-    COLOR_ROOM_1,
-    COLOR_ROOM_2,
-    COLOR_ROOM_3,
-    COLOR_ROOM_4,
-    COLOR_ROOM_5,
-    COLOR_ROOM_6,
-    COLOR_ROOM_7,
-    COLOR_ROOM_8,
-    COLOR_ROOM_9,
-    COLOR_ROOM_10,
-    COLOR_ROOM_11,
-    COLOR_ROOM_12,
-    COLOR_ROOM_13,
-    COLOR_ROOM_14,
-    COLOR_ROOM_15,
-    COLOR_TEXT,
-    COLOR_WALL,
-    COLOR_ZONE_CLEAN,
-)
-
-
-color_transparent = (0, 0, 0, 0)
-color_charger = (0, 128, 0, 255)
-color_move = (238, 247, 255, 255)
-color_robot = (255, 255, 204, 255)
-color_no_go = (255, 0, 0, 255)
-color_go_to = (0, 255, 0, 255)
-color_background = (0, 125, 255, 255)
-color_zone_clean = (255, 255, 255, 25)
-color_wall = (255, 255, 0, 255)
-color_text = (255, 255, 255, 255)
-color_grey = (125, 125, 125, 255)
-color_black = (0, 0, 0, 255)
-color_room_0 = (135, 206, 250, 255)
-color_room_1 = (176, 226, 255, 255)
-color_room_2 = (164, 211, 238, 255)
-color_room_3 = (141, 182, 205, 255)
-color_room_4 = (96, 123, 139, 255)
-color_room_5 = (224, 255, 255, 255)
-color_room_6 = (209, 238, 238, 255)
-color_room_7 = (180, 205, 205, 255)
-color_room_8 = (122, 139, 139, 255)
-color_room_9 = (175, 238, 238, 255)
-color_room_10 = (84, 153, 199, 255)
-color_room_11 = (133, 193, 233, 255)
-color_room_12 = (245, 176, 65, 255)
-color_room_13 = (82, 190, 128, 255)
-color_room_14 = (72, 201, 176, 255)
-color_room_15 = (165, 105, 18, 255)
-
-rooms_color = [
-    color_room_0,
-    color_room_1,
-    color_room_2,
-    color_room_3,
-    color_room_4,
-    color_room_5,
-    color_room_6,
-    color_room_7,
-    color_room_8,
-    color_room_9,
-    color_room_10,
-    color_room_11,
-    color_room_12,
-    color_room_13,
-    color_room_14,
-    color_room_15,
-]
-
-base_colors_array = [
-    color_wall,
-    color_zone_clean,
-    color_robot,
-    color_background,
-    color_move,
-    color_charger,
-    color_no_go,
-    color_go_to,
-    color_text,
-]
-
-color_array = [
-    base_colors_array[0],  # color_wall
-    base_colors_array[6],  # color_no_go
-    base_colors_array[7],  # color_go_to
-    color_black,
-    base_colors_array[2],  # color_robot
-    base_colors_array[5],  # color_charger
-    color_text,
-    base_colors_array[4],  # color_move
-    base_colors_array[3],  # color_background
-    base_colors_array[1],  # color_zone_clean
-    color_transparent,
-    rooms_color,
-]
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class ColorsManagment:
-    """Class to manage the colors.
-    Imports and updates the colors from the user configuration."""
-
-    def __init__(self, shared_var):
-        self.shared_var = shared_var
-
-    @staticmethod
-    def add_alpha_to_rgb(alpha_channels, rgb_colors):
-        """
-        Add alpha channel to RGB colors using corresponding alpha channels.
-
-        Args:
-            alpha_channels (List[Optional[float]]): List of alpha channel values (0.0-255.0).
-            rgb_colors (List[Tuple[int, int, int]]): List of RGB colors.
-
-        Returns:
-            List[Tuple[int, int, int, int]]: List of RGBA colors with alpha channel added.
-        """
-        if len(alpha_channels) != len(rgb_colors):
-            _LOGGER.error("Input lists must have the same length.")
-            return []
-
-        result = []
-        for alpha, rgb in zip(alpha_channels, rgb_colors):
-            try:
-                alpha_int = int(alpha)
-                if alpha_int < 0:
-                    alpha_int = 0
-                elif alpha_int > 255:
-                    alpha_int = 255
-
-                if rgb is None:
-                    result.append((0, 0, 0, alpha_int))
-                else:
-                    result.append((rgb[0], rgb[1], rgb[2], alpha_int))
-            except (ValueError, TypeError):
-                result.append(None)
-
-        return result
-
-    def set_initial_colours(self, device_info: dict) -> None:
-        """Set the initial colours for the map."""
-        try:
-            user_colors = [
-                device_info.get(COLOR_WALL, color_wall),
-                device_info.get(COLOR_ZONE_CLEAN, color_zone_clean),
-                device_info.get(COLOR_ROBOT, color_robot),
-                device_info.get(COLOR_BACKGROUND, color_background),
-                device_info.get(COLOR_MOVE, color_move),
-                device_info.get(COLOR_CHARGER, color_charger),
-                device_info.get(COLOR_NO_GO, color_no_go),
-                device_info.get(COLOR_GO_TO, color_go_to),
-                device_info.get(COLOR_TEXT, color_text),
-            ]
-            user_alpha = [
-                device_info.get(ALPHA_WALL, 255),
-                device_info.get(ALPHA_ZONE_CLEAN, 255),
-                device_info.get(ALPHA_ROBOT, 255),
-                device_info.get(ALPHA_BACKGROUND, 255),
-                device_info.get(ALPHA_MOVE, 255),
-                device_info.get(ALPHA_CHARGER, 255),
-                device_info.get(ALPHA_NO_GO, 255),
-                device_info.get(ALPHA_GO_TO, 255),
-                device_info.get(ALPHA_TEXT, 255),
-            ]
-            rooms_colors = [
-                device_info.get(COLOR_ROOM_0, color_room_0),
-                device_info.get(COLOR_ROOM_1, color_room_1),
-                device_info.get(COLOR_ROOM_2, color_room_2),
-                device_info.get(COLOR_ROOM_3, color_room_3),
-                device_info.get(COLOR_ROOM_4, color_room_4),
-                device_info.get(COLOR_ROOM_5, color_room_5),
-                device_info.get(COLOR_ROOM_6, color_room_6),
-                device_info.get(COLOR_ROOM_7, color_room_7),
-                device_info.get(COLOR_ROOM_8, color_room_8),
-                device_info.get(COLOR_ROOM_9, color_room_9),
-                device_info.get(COLOR_ROOM_10, color_room_10),
-                device_info.get(COLOR_ROOM_11, color_room_11),
-                device_info.get(COLOR_ROOM_12, color_room_12),
-                device_info.get(COLOR_ROOM_13, color_room_13),
-                device_info.get(COLOR_ROOM_14, color_room_14),
-                device_info.get(COLOR_ROOM_15, color_room_15),
-            ]
-            rooms_alpha = [
-                device_info.get(ALPHA_ROOM_0, 255),
-                device_info.get(ALPHA_ROOM_1, 255),
-                device_info.get(ALPHA_ROOM_2, 255),
-                device_info.get(ALPHA_ROOM_3, 255),
-                device_info.get(ALPHA_ROOM_4, 255),
-                device_info.get(ALPHA_ROOM_5, 255),
-                device_info.get(ALPHA_ROOM_6, 255),
-                device_info.get(ALPHA_ROOM_7, 255),
-                device_info.get(ALPHA_ROOM_8, 255),
-                device_info.get(ALPHA_ROOM_9, 255),
-                device_info.get(ALPHA_ROOM_10, 255),
-                device_info.get(ALPHA_ROOM_11, 255),
-                device_info.get(ALPHA_ROOM_12, 255),
-                device_info.get(ALPHA_ROOM_13, 255),
-                device_info.get(ALPHA_ROOM_14, 255),
-                device_info.get(ALPHA_ROOM_15, 255),
-            ]
-            self.shared_var.update_user_colors(
-                self.add_alpha_to_rgb(user_alpha, user_colors)
-            )
-            self.shared_var.update_rooms_colors(
-                self.add_alpha_to_rgb(rooms_alpha, rooms_colors)
-            )
-        except (ValueError, IndexError, UnboundLocalError) as e:
-            _LOGGER.error("Error while populating colors: %s", e)