valetudo-map-parser 0.1.10rc7__py3-none-any.whl → 0.1.11b1__py3-none-any.whl

valetudo_map_parser/config/enhanced_drawable.py

@@ -1,324 +0,0 @@
-"""
-Enhanced Drawable Class.
-Provides drawing utilities with element selection support.
-Version: 0.1.9
-"""
-
-from __future__ import annotations
-
-import logging
-
-# math is not used in this file
-from typing import Optional, Tuple
-
-import numpy as np
-
-from .colors import ColorsManagement
-from .drawable import Drawable
-from .drawable_elements import (
-    DrawableElement,
-    DrawingConfig,
-)
-
-
-# Type aliases
-NumpyArray = np.ndarray
-Color = Tuple[int, int, int, int]
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class EnhancedDrawable(Drawable):
-    """Enhanced drawing utilities with element selection support."""
-
-    def __init__(self, drawing_config: Optional[DrawingConfig] = None):
-        """Initialize with optional drawing configuration."""
-        super().__init__()
-        self.drawing_config = drawing_config or DrawingConfig()
-
-    # Color blending methods have been moved to ColorsManagement class in colors.py
-
-    # Pixel blending methods have been moved to ColorsManagement class in colors.py
-
-    async def draw_map(
-        self, map_data: dict, base_array: Optional[NumpyArray] = None
-    ) -> NumpyArray:
-        """
-        Draw the map with selected elements.
-
-        Args:
-            map_data: The map data dictionary
-            base_array: Optional base array to draw on
-
-        Returns:
-            The image array with all elements drawn
-        """
-        # Get map dimensions
-        size_x = map_data.get("size", {}).get("x", 1024)
-        size_y = map_data.get("size", {}).get("y", 1024)
-
-        # Create empty image if none provided
-        if base_array is None:
-            background_color = self.drawing_config.get_property(
-                DrawableElement.FLOOR, "color", (200, 200, 200, 255)
-            )
-            base_array = await self.create_empty_image(size_x, size_y, background_color)
-
-        # Draw elements in order of z-index
-        for element in self.drawing_config.get_drawing_order():
-            if element == DrawableElement.FLOOR:
-                base_array = await self._draw_floor(map_data, base_array)
-            elif element == DrawableElement.WALL:
-                base_array = await self._draw_walls(map_data, base_array)
-            elif element == DrawableElement.ROBOT:
-                base_array = await self._draw_robot(map_data, base_array)
-            elif element == DrawableElement.CHARGER:
-                base_array = await self._draw_charger(map_data, base_array)
-            elif element == DrawableElement.VIRTUAL_WALL:
-                base_array = await self._draw_virtual_walls(map_data, base_array)
-            elif element == DrawableElement.RESTRICTED_AREA:
-                base_array = await self._draw_restricted_areas(map_data, base_array)
-            elif element == DrawableElement.NO_MOP_AREA:
-                base_array = await self._draw_no_mop_areas(map_data, base_array)
-            elif element == DrawableElement.PATH:
-                base_array = await self._draw_path(map_data, base_array)
-            elif element == DrawableElement.PREDICTED_PATH:
-                base_array = await self._draw_predicted_path(map_data, base_array)
-            elif element == DrawableElement.GO_TO_TARGET:
-                base_array = await self._draw_go_to_target(map_data, base_array)
-            elif DrawableElement.ROOM_1 <= element <= DrawableElement.ROOM_15:
-                room_id = element - DrawableElement.ROOM_1 + 1
-                base_array = await self._draw_room(map_data, room_id, base_array)
-
-        return base_array
-
-    async def _draw_floor(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw the floor layer."""
-        if not self.drawing_config.is_enabled(DrawableElement.FLOOR):
-            return array
-
-        # Implementation depends on the map data format
-        # This is a placeholder - actual implementation would use map_data to draw floor
-
-        return array
-
-    async def _draw_walls(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw the walls."""
-        if not self.drawing_config.is_enabled(DrawableElement.WALL):
-            return array
-
-        # Get wall color from drawing config
-        wall_color = self.drawing_config.get_property(
-            DrawableElement.WALL, "color", (255, 255, 0, 255)
-        )
-
-        # Implementation depends on the map data format
-        # For Valetudo maps, we would look at the layers with type "wall"
-        # This is a simplified example - in a real implementation, we would extract the actual wall pixels
-
-        # Find wall data in map_data
-        wall_pixels = []
-        for layer in map_data.get("layers", []):
-            if layer.get("type") == "wall":
-                # Extract wall pixels from the layer
-                # This is a placeholder - actual implementation would depend on the map data format
-                wall_pixels = layer.get("pixels", [])
-                break
-
-        # Draw wall pixels with color blending
-        for x, y in wall_pixels:
-            # Use sample_and_blend_color from ColorsManagement
-            blended_color = ColorsManagement.sample_and_blend_color(
-                array, x, y, wall_color
-            )
-            if 0 <= y < array.shape[0] and 0 <= x < array.shape[1]:
-                array[y, x] = blended_color
-
-        return array
-
-    async def _draw_robot(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw the robot."""
-        if not self.drawing_config.is_enabled(DrawableElement.ROBOT):
-            return array
-
-        # Get robot color from drawing config
-        robot_color = self.drawing_config.get_property(
-            DrawableElement.ROBOT, "color", (255, 255, 204, 255)
-        )
-
-        # Extract robot position and angle from map_data
-        robot_position = map_data.get("robot", {}).get("position", None)
-        robot_angle = map_data.get("robot", {}).get("angle", 0)
-
-        if robot_position:
-            x, y = robot_position.get("x", 0), robot_position.get("y", 0)
-
-            # Draw robot with color blending
-            # Create a circle around the robot position
-            radius = 25  # Same as in the robot drawing method
-            for dy in range(-radius, radius + 1):
-                for dx in range(-radius, radius + 1):
-                    if dx * dx + dy * dy <= radius * radius:
-                        map_x, map_y = int(x + dx), int(y + dy)
-                        # Use sample_and_blend_color from ColorsManagement
-                        blended_color = ColorsManagement.sample_and_blend_color(
-                            array, map_x, map_y, robot_color
-                        )
-                        if 0 <= map_y < array.shape[0] and 0 <= map_x < array.shape[1]:
-                            array[map_y, map_x] = blended_color
-        return array
-
-    async def _draw_charger(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw the charger."""
-        if not self.drawing_config.is_enabled(DrawableElement.CHARGER):
-            return array
-
-        # Get charger color from drawing config
-        charger_color = self.drawing_config.get_property(
-            DrawableElement.CHARGER, "color", (255, 128, 0, 255)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract charger data from map_data and draw it
-
-        return array
-
-    async def _draw_virtual_walls(
-        self, map_data: dict, array: NumpyArray
-    ) -> NumpyArray:
-        """Draw virtual walls."""
-        if not self.drawing_config.is_enabled(DrawableElement.VIRTUAL_WALL):
-            return array
-
-        # Get virtual wall color from drawing config
-        wall_color = self.drawing_config.get_property(
-            DrawableElement.VIRTUAL_WALL, "color", (255, 0, 0, 255)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract virtual wall data from map_data and draw it
-
-        return array
-
-    async def _draw_restricted_areas(
-        self, map_data: dict, array: NumpyArray
-    ) -> NumpyArray:
-        """Draw restricted areas."""
-        if not self.drawing_config.is_enabled(DrawableElement.RESTRICTED_AREA):
-            return array
-
-        # Get restricted area color from drawing config
-        area_color = self.drawing_config.get_property(
-            DrawableElement.RESTRICTED_AREA, "color", (255, 0, 0, 125)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract restricted area data from map_data and draw it
-
-        return array
-
-    async def _draw_no_mop_areas(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw no-mop areas."""
-        if not self.drawing_config.is_enabled(DrawableElement.NO_MOP_AREA):
-            return array
-
-        # Get no-mop area color from drawing config
-        area_color = self.drawing_config.get_property(
-            DrawableElement.NO_MOP_AREA, "color", (0, 0, 255, 125)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract no-mop area data from map_data and draw it
-
-        return array
-
-    async def _draw_path(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw the robot's path."""
-        if not self.drawing_config.is_enabled(DrawableElement.PATH):
-            return array
-
-        # Get path color from drawing config
-        path_color = self.drawing_config.get_property(
-            DrawableElement.PATH, "color", (238, 247, 255, 255)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract path data from map_data and draw it
-
-        return array
-
-    async def _draw_predicted_path(
-        self, map_data: dict, array: NumpyArray
-    ) -> NumpyArray:
-        """Draw the predicted path."""
-        if not self.drawing_config.is_enabled(DrawableElement.PREDICTED_PATH):
-            return array
-
-        # Get predicted path color from drawing config
-        path_color = self.drawing_config.get_property(
-            DrawableElement.PREDICTED_PATH, "color", (238, 247, 255, 125)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract predicted path data from map_data and draw it
-
-        return array
-
-    async def _draw_go_to_target(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw the go-to target."""
-        if not self.drawing_config.is_enabled(DrawableElement.GO_TO_TARGET):
-            return array
-
-        # Get go-to target color from drawing config
-        target_color = self.drawing_config.get_property(
-            DrawableElement.GO_TO_TARGET, "color", (0, 255, 0, 255)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract go-to target data from map_data and draw it
-
-        return array
-
-    async def _draw_room(
-        self, map_data: dict, room_id: int, array: NumpyArray
-    ) -> NumpyArray:
-        """Draw a specific room."""
-        element = getattr(DrawableElement, f"ROOM_{room_id}")
-        if not self.drawing_config.is_enabled(element):
-            return array
-
-        # Get room color from drawing config
-        room_color = self.drawing_config.get_property(
-            element,
-            "color",
-            (135, 206, 250, 255),  # Default light blue
-        )
-
-        # Implementation depends on the map data format
-        # For Valetudo maps, we would look at the layers with type "segment"
-        # This is a simplified example - in a real implementation, we would extract the actual room pixels
-
-        # Find room data in map_data
-        room_pixels = []
-        for layer in map_data.get("layers", []):
-            if layer.get("type") == "segment" and str(
-                layer.get("metaData", {}).get("segmentId")
-            ) == str(room_id):
-                # Extract room pixels from the layer
-                # This is a placeholder - actual implementation would depend on the map data format
-                # For example, it might use compressed pixels or other data structures
-
-                # For demonstration, let's assume we have a list of (x, y) coordinates
-                room_pixels = layer.get("pixels", [])
-                break
-
-        # Draw room pixels with color blending
-        for x, y in room_pixels:
-            # Use sample_and_blend_color from ColorsManagement
-            blended_color = ColorsManagement.sample_and_blend_color(
-                array, x, y, room_color
-            )
-            if 0 <= y < array.shape[0] and 0 <= x < array.shape[1]:
-                array[y, x] = blended_color
-
-        return array

valetudo_map_parser-0.1.10rc7.dist-info/RECORD

@@ -1,35 +0,0 @@
-valetudo_map_parser/__init__.py,sha256=re58j6L6cWDartKcpimFbkXN3AsItm9Al4K2T62SeMc,1822
-valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
-valetudo_map_parser/config/async_utils.py,sha256=e1j9uTtg4dhPVWvB2_XgqaH4aeSjRAPz-puRMbGoOs8,3204
-valetudo_map_parser/config/auto_crop.py,sha256=oNb8oazitd0h5q3hUkCZXeF7KxDGK90QuugLe5VEZeo,18180
-valetudo_map_parser/config/color_utils.py,sha256=nXD6WeNmdFdoMxPDW-JFpjnxJSaZR1jX-ouNfrx6zvE,4502
-valetudo_map_parser/config/colors.py,sha256=DMY5aHDS-alW2CZ2j8U7QVGHK_H8M0fBDX2OGuryirc,29914
-valetudo_map_parser/config/drawable.py,sha256=npc4eReHvc1Aw-mbK1o0AJgyqn8fu2v1AxR5H1hvP5k,33338
-valetudo_map_parser/config/drawable_elements.py,sha256=o-5oiXmfqPwNQLzKIhkEcZD_A47rIU9E0CqKgWipxgc,11516
-valetudo_map_parser/config/enhanced_drawable.py,sha256=QlGxlUMVgECUXPtFwIslyjubWxQuhIixsRymWV3lEvk,12586
-valetudo_map_parser/config/fonts/FiraSans.ttf,sha256=Pavz1Iv0WZ-Vz_2S-Z6kJqAU1TEfUqXrXsOvJl6XzZc,440984
-valetudo_map_parser/config/fonts/Inter-VF.ttf,sha256=zzy0OwNm4txt9g4RMrHJpMFXd_DNjlpT4MFRJAA-ntQ,804612
-valetudo_map_parser/config/fonts/Lato-Regular.ttf,sha256=6CVCrtgpP0n8g8Sq6lZrH2tPx6mrXaEeb7m8CXO1Mks,75152
-valetudo_map_parser/config/fonts/MPLUSRegular.ttf,sha256=IGdcNSRP4dDxQskbE3Ybuwz7T0flhCBuzwfhLMcPt9s,3380812
-valetudo_map_parser/config/fonts/NotoKufiArabic-VF.ttf,sha256=NaIy40eLx7d3ts0kuenp0GjWd-YN24J6DpSvX2L3vLA,433800
-valetudo_map_parser/config/fonts/NotoSansCJKhk-VF.ttf,sha256=xIXXLKCJzmWoPEg8HdvxeRgotMjjxF6l6ugGP-IWRJU,36135040
-valetudo_map_parser/config/fonts/NotoSansKhojki.ttf,sha256=XJWzSmpN-Ql6jTfTvFojP_JkCHOztQvixQc1_7hPWrc,107388
-valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
-valetudo_map_parser/config/rand256_parser.py,sha256=jsUiuShrNY3UpgfdEMgmTJjH6fj-lC-0y2TdIt43aG0,20161
-valetudo_map_parser/config/shared.py,sha256=58R6kaYl7RF0ESTIKarVy8pB1jo4LUlPHTb27_ubZFo,11789
-valetudo_map_parser/config/status_text/status_text.py,sha256=PaynYW11vXH_vhDxhZrR9j-xeDrCxbB6YQQtN-kcaxQ,4052
-valetudo_map_parser/config/status_text/translations.py,sha256=mmPbJkl_2A59w49wnesQf3ocXqwZxBsrqNX-yt5FSCQ,9132
-valetudo_map_parser/config/types.py,sha256=vSJjEsosbx9ZaM_JEuqhdzFIHnf97bfzDBMvx_V3U0s,18067
-valetudo_map_parser/config/utils.py,sha256=sk6Vy3_QpJhX9Hvb6S36Womyu0n8bfxWejfuNEaEM-I,38658
-valetudo_map_parser/hypfer_draw.py,sha256=4zajujSOvtpRI_GMlmlioM3mDo19MvuOP861LhZmVlw,22495
-valetudo_map_parser/hypfer_handler.py,sha256=8g2zitibQkgVh-crqDO41kp1DQzZaMMixUdFqgPjfis,20477
-valetudo_map_parser/map_data.py,sha256=OSscuvlYpAZ9q7pfjzIjh98UvT0PV8zjPk5eUEwmLb8,27355
-valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand256_handler.py,sha256=jpbvhNr2tm6Gp1Xs7yMMLwjCN1dOnNUtED7MrjnH4Os,21504
-valetudo_map_parser/reimg_draw.py,sha256=tDQGMDTYprgPZjETxws3rzgVfpPxm_K-armzYFyGzGw,12474
-valetudo_map_parser/rooms_handler.py,sha256=tE8BrXcdL0SeFAYsdFvjR3NVDfDi2RPKnXw9jD1e5k8,17494
-valetudo_map_parser-0.1.10rc7.dist-info/METADATA,sha256=NPYlwO902_zvejWWjfzzjOkTVyn_CoquAG9zs1cRG0E,3404
-valetudo_map_parser-0.1.10rc7.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-valetudo_map_parser-0.1.10rc7.dist-info/licenses/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.10rc7.dist-info/licenses/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.10rc7.dist-info/RECORD,,