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

valetudo_map_parser/reimg_draw.py

@@ -1,18 +1,18 @@
 """
 Image Draw Class for Valetudo Rand256 Image Handling.
 This class is used to simplify the ImageHandler class.
-Version: 2024.12.0
+Version: 0.1.9.b42
 """
 
 from __future__ import annotations
 
-import hashlib
-import json
 import logging
 
-from .config.types import Color, JsonType, NumpyArray
 from .config.drawable import Drawable
-from .map_data import ImageData
+from .config.drawable_elements import DrawableElement
+from .config.types import Color, JsonType, NumpyArray
+from .map_data import ImageData, RandImageData
+
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -20,12 +20,11 @@ _LOGGER = logging.getLogger(__name__)
 class ImageDraw:
     """Class to handle the image creation."""
 
-    """It Draws each elements of the images, like the walls, zones, paths, etc."""
-
     def __init__(self, image_handler):
         self.img_h = image_handler
         self.file_name = self.img_h.shared.file_name
-        self.data = ImageData
+        self.data = RandImageData
+        self.data_sup = ImageData
         self.draw = Drawable
         self.color_grey = (128, 128, 128, 255)
 
@@ -47,12 +46,13 @@ class ImageDraw:
                     np_array = await self.draw.lines(
                         np_array, predicted_path, 3, self.color_grey
                     )
-                return np_array
-            else:
-                return np_array
-        except Exception as e:
+            return np_array
+        except KeyError as e:
             _LOGGER.warning(
-                f"{self.file_name}: Error in extraction of go to. {e}", exc_info=True
+                "%s: Error in extraction of go-to target: %s",
+                self.file_name,
+                e,
+                exc_info=True,
             )
             return np_array
 
@@ -70,7 +70,7 @@ class ImageDraw:
                 )
         except ValueError as e:
             self.img_h.segment_data = None
-            _LOGGER.info(f"{self.file_name}: No segments data found. {e}")
+            _LOGGER.info("%s: No segments data found: %s", self.file_name, e)
 
     async def async_draw_base_layer(
         self,
@@ -87,13 +87,13 @@ class ImageDraw:
         walls_data = self.data.get_rrm_walls(m_json)
         floor_data = self.data.get_rrm_floor(m_json)
 
-        _LOGGER.info(self.file_name + ": Empty image with background color")
+        _LOGGER.info("%s: Empty image with background color", self.file_name)
         img_np_array = await self.draw.create_empty_image(
             self.img_h.img_size["x"], self.img_h.img_size["y"], color_background
         )
         room_id = 0
         if self.img_h.frame_number == 0:
-            _LOGGER.info(self.file_name + ": Overlapping Layers")
+            _LOGGER.info("%s: Overlapping Layers", self.file_name)
 
             # checking if there are segments too (sorted pixels in the raw data).
             await self.async_segment_data(m_json, size_x, size_y, pos_top, pos_left)
@@ -108,16 +108,18 @@ class ImageDraw:
                 color_wall,
                 color_zone_clean,
             )
-            img_np_array = await self._draw_walls(
-                img_np_array,
-                walls_data,
-                size_x,
-                size_y,
-                pos_top,
-                pos_left,
-                pixel_size,
-                color_wall,
-            )
+            # Draw walls only if enabled in drawing config
+            if self.img_h.drawing_config.is_enabled(DrawableElement.WALL):
+                img_np_array = await self._draw_walls(
+                    img_np_array,
+                    walls_data,
+                    size_x,
+                    size_y,
+                    pos_top,
+                    pos_left,
+                    pixel_size,
+                    color_wall,
+                )
         return room_id, img_np_array
 
     async def _draw_floor(
@@ -146,31 +148,30 @@ class ImageDraw:
         room_id = 0
         rooms_list = [color_wall]
         if not segment_data:
-            _LOGGER.info(f"{self.file_name}: No segments data found.")
+            _LOGGER.info("%s: No segments data found.", self.file_name)
             return room_id, img_np_array
 
-        if segment_data:
-            _LOGGER.info(f"{self.file_name}: Drawing segments.")
-            for pixels in segment_data:
-                room_color = self.img_h.shared.rooms_colors[room_id]
-                rooms_list.append(room_color)
-                if (
-                    self.img_h.active_zones
-                    and len(self.img_h.active_zones) > room_id
-                    and self.img_h.active_zones[room_id] == 1
-                ):
-                    room_color = (
-                        ((2 * room_color[0]) + color_zone_clean[0]) // 3,
-                        ((2 * room_color[1]) + color_zone_clean[1]) // 3,
-                        ((2 * room_color[2]) + color_zone_clean[2]) // 3,
-                        ((2 * room_color[3]) + color_zone_clean[3]) // 3,
-                    )
-                img_np_array = await self.draw.from_json_to_image(
-                    img_np_array, pixels, pixel_size, room_color
+        _LOGGER.info("%s: Drawing segments.", self.file_name)
+        for pixels in segment_data:
+            room_color = self.img_h.shared.rooms_colors[room_id]
+            rooms_list.append(room_color)
+            if (
+                self.img_h.active_zones
+                and len(self.img_h.active_zones) > room_id
+                and self.img_h.active_zones[room_id] == 1
+            ):
+                room_color = (
+                    ((2 * room_color[0]) + color_zone_clean[0]) // 3,
+                    ((2 * room_color[1]) + color_zone_clean[1]) // 3,
+                    ((2 * room_color[2]) + color_zone_clean[2]) // 3,
+                    ((2 * room_color[3]) + color_zone_clean[3]) // 3,
                 )
-                room_id += 1
-                if room_id > 15:
-                    room_id = 0
+            img_np_array = await self.draw.from_json_to_image(
+                img_np_array, pixels, pixel_size, room_color
+            )
+            room_id += 1
+            if room_id > 15:
+                room_id = 0
         return room_id, img_np_array
 
     async def _draw_walls(
@@ -209,10 +210,10 @@ class ImageDraw:
             charger_pos = self.data.rrm_coordinates_to_valetudo(
                 self.data.get_rrm_charger_position(m_json)
             )
-        except Exception as e:
-            _LOGGER.warning(f"{self.file_name}: No charger position found. {e}")
+        except KeyError as e:
+            _LOGGER.warning("%s: No charger position found: %s", self.file_name, e)
         else:
-            _LOGGER.debug("charger position: %s", charger_pos)
+            _LOGGER.debug("Charger position: %s", charger_pos)
             if charger_pos:
                 charger_pos_dictionary = {
                     "x": (charger_pos[0] * 10),
@@ -223,8 +224,7 @@ class ImageDraw:
                     np_array, charger_pos[0], charger_pos[1], color_charger
                 )
                 return np_array, charger_pos_dictionary
-            else:
-                return np_array, {}
+        return np_array, {}
 
     async def async_draw_zones(
         self,
@@ -237,12 +237,11 @@ class ImageDraw:
             zone_clean = self.data.get_rrm_currently_cleaned_zones(m_json)
         except (ValueError, KeyError):
             zone_clean = None
-        else:
-            _LOGGER.info(f"{self.file_name}: Got zones.")
+
         if zone_clean:
+            _LOGGER.info("%s: Got zones.", self.file_name)
             return await self.draw.zones(np_array, zone_clean, color_zone_clean)
-        else:
-            return np_array
+        return np_array
 
     async def async_draw_virtual_restrictions(
         self, m_json: JsonType, np_array: NumpyArray, color_no_go: Color
@@ -252,9 +251,9 @@ class ImageDraw:
             virtual_walls = self.data.get_rrm_virtual_walls(m_json)
         except (ValueError, KeyError):
             virtual_walls = None
-        else:
-            _LOGGER.info(f"{self.file_name}: Got virtual walls.")
+
         if virtual_walls:
+            _LOGGER.info("%s: Got virtual walls.", self.file_name)
             np_array = await self.draw.draw_virtual_walls(
                 np_array, virtual_walls, color_no_go
             )
@@ -278,11 +277,13 @@ class ImageDraw:
         # Extract the paths data from the JSON data.
         try:
             path_pixel = self.data.get_rrm_path(m_json)
-            path_pixel_formatted = self.data.sublist_join(
+            path_pixel_formatted = self.data_sup.sublist_join(
                 self.data.rrm_valetudo_path_array(path_pixel["points"]), 2
             )
         except KeyError as e:
-            _LOGGER.warning(f"{self.file_name}: Error extracting paths data: {str(e)}")
+            _LOGGER.warning(
+                "%s: Error extracting paths data: %s", self.file_name, str(e)
+            )
         finally:
             if path_pixel_formatted:
                 np_array = await self.draw.lines(
@@ -293,32 +294,13 @@ class ImageDraw:
     async def async_get_entity_data(self, m_json: JsonType) -> dict or None:
         """Get the entity data from the JSON data."""
         try:
-            entity_dict = self.data.find_points_entities(m_json)
+            entity_dict = self.data_sup.find_points_entities(m_json)
         except (ValueError, KeyError):
             entity_dict = None
         else:
-            _LOGGER.info(f"{self.file_name}: Got the points in the json.")
+            _LOGGER.info("%s: Got the points in the json.", self.file_name)
         return entity_dict
 
-    @staticmethod
-    async def async_copy_array(original_array: NumpyArray) -> NumpyArray:
-        """Copy the array."""
-        return NumpyArray.copy(original_array)
-
-    async def calculate_array_hash(self, layers: dict, active: list[int] = None) -> str:
-        """Calculate the hash of the image based on the layers and active segments walls."""
-        self.img_h.active_zones = active
-        if layers and active:
-            data_to_hash = {
-                "layers": len(layers["wall"][0]),
-                "active_segments": tuple(active),
-            }
-            data_json = json.dumps(data_to_hash, sort_keys=True)
-            hash_value = hashlib.sha256(data_json.encode()).hexdigest()
-        else:
-            hash_value = None
-        return hash_value
-
     async def async_get_robot_position(self, m_json: JsonType) -> tuple | None:
         """Get the robot position from the entity data."""
         robot_pos = None
@@ -329,14 +311,16 @@ class ImageDraw:
             robot_pos = self.data.rrm_coordinates_to_valetudo(robot_pos_data)
             angle = self.data.get_rrm_robot_angle(m_json)
         except (ValueError, KeyError):
-            _LOGGER.warning(f"{self.file_name} No robot position found.")
+            _LOGGER.warning("%s No robot position found.", self.file_name)
             return None, None, None
         finally:
             robot_position_angle = round(angle[0], 0)
             if robot_pos and robot_position_angle:
                 robot_position = robot_pos
                 _LOGGER.debug(
-                    f"robot position: {robot_pos}, robot angle: {robot_position_angle}"
+                    "robot position: %s, robot angle: %s",
+                    str(robot_pos),
+                    str(robot_position_angle),
                 )
                 if self.img_h.rooms_pos is None:
                     self.img_h.robot_pos = {