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

valetudo_map_parser/map_data.py

@@ -10,47 +10,12 @@ from __future__ import annotations
 
 import numpy as np
 
-from .config.types import (
-    Colors,
-    ImageSize,
-    JsonType,
-    NumpyArray,
-)
+from .config.types import ImageSize, JsonType
 
 
 class ImageData:
     """Class to handle the image data."""
 
-    @staticmethod
-    async def async_extract_color_coordinates(
-        source_array: NumpyArray, search_for_colours_list: Colors
-    ) -> list:
-        """Search for specific colors in an image array and return their coordinates."""
-        # Initialize an empty list to store color and coordinates tuples
-        color_coordinates_list = []
-
-        # Iterate over the search_for_colours_list
-        for color_to_search in search_for_colours_list:
-            # Initialize an empty list to store coordinates for the current color
-            color_coordinates = []
-
-            # Iterate over the image array
-            for y in range(source_array.shape[0]):
-                for x in range(source_array.shape[1]):
-                    # Extract the pixel color at the current coordinates
-                    pixel_color = source_array[y, x]
-
-                    # Check if the current pixel color matches the color_to_search
-                    if np.all(pixel_color == color_to_search):
-                        # Record the coordinates for the current color
-                        color_coordinates.append((x, y))
-
-            # Append the color and its coordinates to the final list
-            color_coordinates_list.append((color_to_search, color_coordinates))
-
-        # Return the final list of color and coordinates tuples
-        return color_coordinates_list
-
     @staticmethod
     def sublist(lst, n):
         """Sub lists of specific n number of elements"""
@@ -69,6 +34,30 @@ class ImageData:
     # list the specific Layers, Paths, Zones and Pints in the
     # Vacuums Json in parallel.
 
+    @staticmethod
+    def get_obstacles(entity_dict: dict) -> list:
+        """Get the obstacles positions from the entity data."""
+        try:
+            obstacle_data = entity_dict.get("obstacle")
+        except KeyError:
+            return []
+        obstacle_positions = []
+        if obstacle_data:
+            for obstacle in obstacle_data:
+                label = obstacle.get("metaData", {}).get("label")
+                points = obstacle.get("points", [])
+                image_id = obstacle.get("metaData", {}).get("id")
+
+                if label and points:
+                    obstacle_pos = {
+                        "label": label,
+                        "points": {"x": points[0], "y": points[1]},
+                        "id": image_id,
+                    }
+                    obstacle_positions.append(obstacle_pos)
+            return obstacle_positions
+        return []
+
     @staticmethod
     def find_layers(
         json_obj: JsonType, layer_dict: dict, active_list: list
@@ -209,10 +198,11 @@ class ImageData:
             max_y * pixel_size,
         )
 
-    # Added below in order to support Valetudo Re.
-    # This functions read directly the data from the json created
-    # from the parser for Valetudo Re. They allow to use the
-    # functions to draw the image without changes on the drawing class.
+
+class RandImageData:
+    """This functions read directly the data from the json created
+    from the parser for Valetudo Re. They allow to use the
+    functions to draw the image without changes on the drawing class."""
 
     @staticmethod
     def from_rrm_to_compressed_pixels(
@@ -243,7 +233,7 @@ class ImageData:
         return compressed_pixels
 
     @staticmethod
-    def calculate_max_x_y(coord_array):
+    def _calculate_max_x_y(coord_array):
         """Calculate the max and min x and y coordinates."""
         max_x = -float("inf")
         max_y = -float("inf")
@@ -297,7 +287,7 @@ class ImageData:
         except KeyError:
             return None
         predicted_path = ImageData.sublist_join(
-            ImageData.rrm_valetudo_path_array(points), 2
+            RandImageData.rrm_valetudo_path_array(points), 2
         )
         return predicted_path
 
@@ -318,8 +308,17 @@ class ImageData:
         Return the calculated angle and original angle.
         """
         angle_c = round(json_data.get("robot_angle", 0))
-        angle = (360 - angle_c + 80) if angle_c < 0 else (180 - angle_c - 80)
-        return angle % 360, json_data.get("robot_angle", 0)
+        # Convert negative values: -10 -> 350, -180 -> 359, but keep positive: 24 -> 24
+        if angle_c < 0:
+            if angle_c == -180:
+                angle = 359  # -180 becomes 359 (avoiding 360)
+            else:
+                angle = 360 + angle_c  # -10 -> 350, -90 -> 270
+        else:
+            angle = angle_c
+
+        angle = (angle + 90) % 360
+        return angle, json_data.get("robot_angle", 0)
 
     @staticmethod
     def get_rrm_goto_target(json_data: JsonType) -> list or None:
@@ -330,7 +329,7 @@ class ImageData:
             return None
 
         if path_data and path_data != []:
-            path_data = ImageData.rrm_coordinates_to_valetudo(path_data)
+            path_data = RandImageData.rrm_coordinates_to_valetudo(path_data)
             return path_data
         return None
 
@@ -338,18 +337,18 @@ class ImageData:
     def get_rrm_currently_cleaned_zones(json_data: JsonType) -> dict:
         """Get the currently cleaned zones from the json."""
         re_zones = json_data.get("currently_cleaned_zones", [])
-        formatted_zones = ImageData.rrm_valetudo_format_zone(re_zones)
+        formatted_zones = RandImageData._rrm_valetudo_format_zone(re_zones)
         return formatted_zones
 
     @staticmethod
     def get_rrm_forbidden_zones(json_data: JsonType) -> dict:
         """Get the forbidden zones from the json."""
         re_zones = json_data.get("forbidden_zones", [])
-        formatted_zones = ImageData.rrm_valetudo_format_zone(re_zones)
+        formatted_zones = RandImageData._rrm_valetudo_format_zone(re_zones)
         return formatted_zones
 
     @staticmethod
-    def rrm_valetudo_format_zone(coordinates: list) -> any:
+    def _rrm_valetudo_format_zone(coordinates: list) -> any:
         """Format the zones from RRM to Valetudo."""
         formatted_zones = []
         for zone_data in coordinates:
@@ -391,7 +390,7 @@ class ImageData:
         return formatted_zones
 
     @staticmethod
-    def rrm_valetudo_lines(coordinates: list) -> list:
+    def _rrm_valetudo_lines(coordinates: list) -> list:
         """Format the lines from RRM to Valetudo."""
         formatted_lines = []
         for lines in coordinates:
@@ -406,7 +405,7 @@ class ImageData:
             tmp_data = json_data.get("virtual_walls", [])
         except KeyError:
             return None
-        virtual_walls = ImageData.rrm_valetudo_lines(tmp_data)
+        virtual_walls = RandImageData._rrm_valetudo_lines(tmp_data)
         return virtual_walls
 
     @staticmethod
@@ -424,7 +423,7 @@ class ImageData:
         """Get the image size from the json."""
         if isinstance(json_data, tuple):
             return 0, 0
-        image = ImageData.get_rrm_image(json_data)
+        image = RandImageData.get_rrm_image(json_data)
         if image == {}:
             return 0, 0
         dimensions = image.get("dimensions", {})
@@ -433,20 +432,20 @@ class ImageData:
     @staticmethod
     def get_rrm_image_position(json_data: JsonType) -> tuple:
         """Get the image position from the json."""
-        image = ImageData.get_rrm_image(json_data)
+        image = RandImageData.get_rrm_image(json_data)
         position = image.get("position", {})
         return position.get("top", 0), position.get("left", 0)
 
     @staticmethod
     def get_rrm_floor(json_data: JsonType) -> list:
         """Get the floor data from the json."""
-        img = ImageData.get_rrm_image(json_data)
+        img = RandImageData.get_rrm_image(json_data)
         return img.get("pixels", {}).get("floor", [])
 
     @staticmethod
     def get_rrm_walls(json_data: JsonType) -> list:
         """Get the walls data from the json."""
-        img = ImageData.get_rrm_image(json_data)
+        img = RandImageData.get_rrm_image(json_data)
         return img.get("pixels", {}).get("walls", [])
 
     @staticmethod
@@ -460,7 +459,7 @@ class ImageData:
     ) -> tuple or list:
         """Get the segments data from the json."""
 
-        img = ImageData.get_rrm_image(json_data)
+        img = RandImageData.get_rrm_image(json_data)
         seg_data = img.get("segments", {})
         seg_ids = seg_data.get("id")
         segments = []
@@ -469,7 +468,7 @@ class ImageData:
         for id_seg in seg_ids:
             tmp_data = seg_data.get("pixels_seg_" + str(id_seg))
             segments.append(
-                ImageData.from_rrm_to_compressed_pixels(
+                RandImageData.from_rrm_to_compressed_pixels(
                     tmp_data,
                     image_width=size_x,
                     image_height=size_y,
@@ -493,17 +492,8 @@ class ImageData:
     def get_rrm_segments_ids(json_data: JsonType) -> list or None:
         """Get the segments ids from the json."""
         try:
-            img = ImageData.get_rrm_image(json_data)
+            img = RandImageData.get_rrm_image(json_data)
             seg_ids = img.get("segments", {}).get("id", [])
         except KeyError:
             return None
         return seg_ids
-
-    @staticmethod
-    def convert_negative_angle(angle: int) -> int:
-        """Convert negative angle to positive."""
-        angle_c = angle % 360  # Ensure angle is within 0-359
-        if angle_c < 0:
-            angle_c += 360  # Convert negative angle to positive
-        angle = angle_c + 180  # add offset
-        return angle