pymammotion 0.2.62__py3-none-any.whl → 0.5.51__py3-none-any.whl

pymammotion/data/model/hash_list.py

@@ -2,8 +2,13 @@ from dataclasses import dataclass, field
 from enum import IntEnum
 
 from mashumaro.mixins.orjson import DataClassORJSONMixin
+from shapely import Point
 
-from pymammotion.proto.mctrl_nav import NavGetCommDataAck, NavGetHashListAck
+from pymammotion.data.model.generate_geojson import GeoJSONCollection, generate_geojson
+from pymammotion.data.model.location import Dock, LocationPoint
+from pymammotion.proto import NavGetCommDataAck, NavGetHashListAck, SvgMessageAckT
+from pymammotion.utility.map import CoordinateConverter
+from pymammotion.utility.mur_mur_hash import MurMurHashUtil
 
 
 class PathType(IntEnum):
@@ -12,24 +17,175 @@ class PathType(IntEnum):
     AREA = 0
     OBSTACLE = 1
     PATH = 2
+    LINE = 10
     DUMP = 12
+    SVG = 13
+
+
+@dataclass
+class CommDataCouple:
+    x: float = 0.0
+    y: float = 0.0
+
+
+@dataclass
+class AreaLabelName(DataClassORJSONMixin):
+    label: str = ""
+
+
+@dataclass
+class NavNameTime(DataClassORJSONMixin):
+    name: str = ""
+    create_time: int = 0
+    modify_time: int = 0
+
+
+@dataclass
+class NavGetCommData(DataClassORJSONMixin):
+    pver: int = 0
+    sub_cmd: int = 0
+    result: int = 0
+    action: int = 0
+    type: int = 0
+    hash: int = 0
+    paternal_hash_a: int = 0
+    paternal_hash_b: int = 0
+    total_frame: int = 0
+    current_frame: int = 0
+    data_hash: int = 0
+    data_len: int = 0
+    data_couple: list["CommDataCouple"] = field(default_factory=list)
+    reserved: str = ""
+    name_time: NavNameTime = field(default_factory=NavNameTime)
+
+
+@dataclass
+class MowPathPacket(DataClassORJSONMixin):
+    path_hash: int = 0
+    path_type: int = 0
+    path_total: int = 0
+    path_cur: int = 0
+    zone_hash: int = 0
+    data_couple: list["CommDataCouple"] = field(default_factory=list)
+
+
+@dataclass
+class MowPath(DataClassORJSONMixin):
+    pver: int = 0
+    sub_cmd: int = 0
+    result: int = 0
+    area: int = 0
+    time: int = 0
+    total_frame: int = 0
+    current_frame: int = 0
+    total_path_num: int = 0
+    valid_path_num: int = 0
+    data_hash: int = 0
+    transaction_id: int = 0
+    reserved: list[int] = field(default_factory=list)
+    data_len: int = 0
+    path_packets: list[MowPathPacket] = field(default_factory=list)
+
+
+@dataclass
+class SvgMessageData(DataClassORJSONMixin):
+    x_move: float = 0.0
+    y_move: float = 0.0
+    scale: float = 0.0
+    rotate: float = 0.0
+    base_width_m: float = 0.0
+    base_width_pix: int = 0
+    base_height_m: float = 0.0
+    base_height_pix: int = 0
+    data_count: int = 0
+    hide_svg: bool = False
+    name_count: int = 0
+    svg_file_name: str = ""
+    svg_file_data: str = ""
+
+
+@dataclass
+class SvgMessage(DataClassORJSONMixin):
+    pver: int = 0
+    sub_cmd: int = 0
+    total_frame: int = 0
+    current_frame: int = 0
+    data_hash: int = 0
+    paternal_hash_a: int = 0
+    type: int = 0
+    result: int = 0
+    svg_message: "SvgMessageData" = field(default_factory=SvgMessageData)
 
 
 @dataclass
 class FrameList(DataClassORJSONMixin):
-    total_frame: int
-    data: list[NavGetCommDataAck]
+    total_frame: int = 0
+    sub_cmd: int = 0
+    data: list[NavGetCommData | SvgMessage] = field(default_factory=list)
 
 
 @dataclass
-class NavGetHashListData(DataClassORJSONMixin, NavGetHashListAck):
+class Plan(DataClassORJSONMixin):
+    pver: int = 0
+    sub_cmd: int = 2
+    area: int = 0
+    work_time: int = 0
+    version: str = ""
+    id: str = ""
+    user_id: str = ""
+    device_id: str = ""
+    plan_id: str = ""
+    task_id: str = ""
+    job_id: str = ""
+    start_time: str = ""
+    end_time: str = ""
+    week: int = 0
+    knife_height: int = 0
+    model: int = 0
+    edge_mode: int = 0
+    required_time: int = 0
+    route_angle: int = 0
+    route_model: int = 0
+    route_spacing: int = 0
+    ultrasonic_barrier: int = 0
+    total_plan_num: int = 0
+    plan_index: int = 0
+    result: int = 0
+    speed: float = 0.0
+    task_name: str = ""
+    job_name: str = ""
+    zone_hashs: list[int] = field(default_factory=list)
+    reserved: str = ""
+    start_date: str = ""
+    end_date: str = ""
+    trigger_type: int = 0
+    day: int = 0
+    weeks: list[int] = field(default_factory=list)
+    remained_seconds: int = 0
+    toward_mode: int = 0
+    toward_included_angle: int = 0
+
+
+@dataclass(eq=False, repr=False)
+class NavGetHashListData(DataClassORJSONMixin):
     """Dataclass for NavGetHashListData."""
 
+    pver: int = 0
+    sub_cmd: int = 0
+    total_frame: int = 0
+    current_frame: int = 0
+    data_hash: int = 0
+    hash_len: int = 0
+    reserved: str = ""
+    result: int = 0
+    data_couple: list[int] = field(default_factory=list)
+
 
 @dataclass
 class RootHashList(DataClassORJSONMixin):
     total_frame: int = 0
-    data: list[NavGetHashListAck] = field(default_factory=list)
+    sub_cmd: int = 0
+    data: list[NavGetHashListData] = field(default_factory=list)
 
 
 @dataclass
@@ -47,81 +203,214 @@ class HashList(DataClassORJSONMixin):
     hashlist for all our hashIDs for verification
     """
 
-    root_hash_list: RootHashList = field(default_factory=RootHashList)
-    area: dict = field(default_factory=dict)  # type 0
-    path: dict = field(default_factory=dict)  # type 2
-    obstacle: dict = field(default_factory=dict)  # type 1
-    dump: dict = field(default_factory=dict)  # type 12?
+    root_hash_lists: list[RootHashList] = field(default_factory=list)
+    area: dict[int, FrameList] = field(default_factory=dict)  # type 0
+    path: dict[int, FrameList] = field(default_factory=dict)  # type 2
+    obstacle: dict[int, FrameList] = field(default_factory=dict)  # type 1
+    dump: dict[int, FrameList] = field(default_factory=dict)  # type 12? / sub cmd 4
+    svg: dict[int, FrameList] = field(default_factory=dict)  # type 13
+    line: dict[int, FrameList] = field(default_factory=dict)  # type 10 possibly breakpoint? / sub cmd 3
+    plan: dict[str, Plan] = field(default_factory=dict)
     area_name: list[AreaHashNameList] = field(default_factory=list)
+    current_mow_path: dict[int, MowPath] = field(default_factory=dict)
+    generated_geojson: GeoJSONCollection = field(default_factory=dict)
 
-    def update_hash_lists(self, hashlist: list[int]) -> None:
+    def update_hash_lists(self, hashlist: list[int], bol_hash: str | None = None) -> None:
+        if bol_hash:
+            self.invalidate_maps(int(bol_hash))
         self.area = {hash_id: frames for hash_id, frames in self.area.items() if hash_id in hashlist}
         self.path = {hash_id: frames for hash_id, frames in self.path.items() if hash_id in hashlist}
         self.obstacle = {hash_id: frames for hash_id, frames in self.obstacle.items() if hash_id in hashlist}
         self.dump = {hash_id: frames for hash_id, frames in self.dump.items() if hash_id in hashlist}
+        self.svg = {hash_id: frames for hash_id, frames in self.svg.items() if hash_id in hashlist}
+
+        area_hashes = list(self.area.keys())
+        for hash_id, plan_task in self.plan.copy().items():
+            for item in plan_task.zone_hashs:
+                if item not in area_hashes:
+                    self.plan.pop(hash_id)
+                    break
+
+        self.area_name = [
+            area_item
+            for area_item in self.area_name
+            if area_item.hash in self.area.keys() or area_item.hash in hashlist
+        ]
 
     @property
     def hashlist(self) -> list[int]:
-        if len(self.root_hash_list.data) == 0:
+        if not self.root_hash_lists:
             return []
-        return [i for obj in self.root_hash_list.data for i in obj.data_couple]
+        # Combine data_couple from all RootHashLists
+        return [i for root_list in self.root_hash_lists for obj in root_list.data for i in obj.data_couple]
 
     @property
-    def missing_hashlist(self) -> list[int]:
+    def area_root_hashlist(self) -> list[int]:
+        if not self.root_hash_lists:
+            return []
+        # Combine data_couple from all RootHashLists
         return [
             i
-            for obj in self.root_hash_list.data
+            for root_list in self.root_hash_lists
+            for obj in root_list.data
             for i in obj.data_couple
-            if i not in set(self.area.keys()).union(self.path.keys(), self.obstacle.keys(), self.dump.keys())
+            if root_list.sub_cmd == 0
         ]
 
-    def update_root_hash_list(self, hash_list: NavGetHashListAck) -> None:
-        self.root_hash_list.total_frame = hash_list.total_frame
+    def missing_hashlist(self, sub_cmd: int = 0) -> list[int]:
+        """Return missing hashlist."""
+        all_hash_ids = set(self.area.keys()).union(
+            self.path.keys(), self.obstacle.keys(), self.dump.keys(), self.svg.keys()
+        )
+        if sub_cmd == 3:
+            all_hash_ids = set(self.line.keys())
+        return [
+            i
+            for root_list in self.root_hash_lists
+            for obj in root_list.data
+            if root_list.sub_cmd == sub_cmd
+            for i in obj.data_couple
+            if i not in all_hash_ids
+        ]
 
-        for index, obj in enumerate(self.root_hash_list.data):
+    def missing_root_hash_frame(self, hash_list: NavGetHashListAck) -> list[int]:
+        """Return missing root hash frame."""
+        target_root_list = next(
+            (
+                rhl
+                for rhl in self.root_hash_lists
+                if rhl.total_frame == hash_list.total_frame and rhl.sub_cmd == hash_list.sub_cmd
+            ),
+            None,
+        )
+        if target_root_list is None:
+            return []
+
+        return self.find_missing_frames(target_root_list)
+
+    def update_root_hash_list(self, hash_list: NavGetHashListData) -> None:
+        target_root_list = next(
+            (
+                rhl
+                for rhl in self.root_hash_lists
+                if rhl.total_frame == hash_list.total_frame and rhl.sub_cmd == hash_list.sub_cmd
+            ),
+            None,
+        )
+
+        if target_root_list is None:
+            # Create new RootHashList if none exists for this total_frame
+            new_root_list = RootHashList(total_frame=hash_list.total_frame, sub_cmd=hash_list.sub_cmd, data=[hash_list])
+            self.root_hash_lists.append(new_root_list)
+            return
+
+        for index, obj in enumerate(target_root_list.data):
             if obj.current_frame == hash_list.current_frame:
                 # Replace the item if current_frame matches
-                self.root_hash_list.data[index] = hash_list
+                target_root_list.data[index] = hash_list
                 return
 
         # If no match was found, append the new item
-        self.root_hash_list.data.append(hash_list)
+        target_root_list.data.append(hash_list)
+
+    def missing_hash_frame(self, hash_ack: NavGetHashListAck) -> list[int]:
+        """Returns a combined list of all missing frames across all RootHashLists."""
+        missing_frames = []
+        filtered_lists = [rl for rl in self.root_hash_lists if rl.sub_cmd == hash_ack.sub_cmd]
+        for root_list in filtered_lists:
+            missing = self.find_missing_frames(root_list)
+            if missing:
+                missing_frames.extend(missing)
+        return missing_frames
+
+    def missing_frame(self, hash_data: NavGetCommDataAck | SvgMessageAckT) -> list[int]:
+        frame_list = self._get_frame_list_by_type_and_hash(hash_data)
+        return self.find_missing_frames(frame_list)
+
+    def _get_frame_list_by_type_and_hash(self, hash_data: NavGetCommDataAck | SvgMessageAckT) -> FrameList | None:
+        """Get the appropriate FrameList based on hash_data type and hash."""
+        path_type_mapping = self._get_path_type_mapping()
+        target_dict = path_type_mapping.get(hash_data.type)
+
+        if target_dict is None:
+            return None
+
+        # Handle SvgMessage with data_hash attribute
+        if isinstance(hash_data, SvgMessageAckT):
+            return target_dict.get(hash_data.data_hash)
+
+        # Handle NavGetCommDataAck with hash attribute
+        return target_dict.get(hash_data.hash)
+
+    def update_plan(self, plan: Plan) -> None:
+        if plan.total_plan_num != 0:
+            self.plan[plan.plan_id] = plan
+
+    def _get_path_type_mapping(self) -> dict[int, dict[int, FrameList]]:
+        """Return mapping of PathType to corresponding hash dictionary."""
+        return {
+            PathType.AREA: self.area,
+            PathType.OBSTACLE: self.obstacle,
+            PathType.PATH: self.path,
+            PathType.LINE: self.line,
+            PathType.DUMP: self.dump,
+            PathType.SVG: self.svg,
+        }
+
+    def update(self, hash_data: NavGetCommData | SvgMessage) -> bool:
+        """Update the map data."""
 
-    def missing_hash_frame(self):
-        return self._find_missing_frames(self.root_hash_list)
+        if hash_data.type == PathType.AREA and isinstance(hash_data, NavGetCommData):
+            existing_name = next((area for area in self.area_name if area.hash == hash_data.hash), None)
+            if not existing_name:
+                name = f"area {len(self.area_name)+1}"
+                self.area_name.append(AreaHashNameList(name=name, hash=hash_data.hash))
+            result = self._add_hash_data(self.area, hash_data)
+            self.update_hash_lists(self.hashlist)
+            return result
 
-    def missing_frame(self, hash_data: NavGetCommDataAck) -> list[int]:
-        if hash_data.type == PathType.AREA:
-            return self._find_missing_frames(self.area.get(hash_data.hash))
+        path_type_mapping = self._get_path_type_mapping()
+        target_dict = path_type_mapping.get(hash_data.type)
 
-        if hash_data.type == PathType.OBSTACLE:
-            return self._find_missing_frames(self.obstacle.get(hash_data.hash))
+        if target_dict is not None:
+            return self._add_hash_data(target_dict, hash_data)
 
-        if hash_data.type == PathType.PATH:
-            return self._find_missing_frames(self.path.get(hash_data.hash))
+        return False
 
-        if hash_data.type == PathType.DUMP:
-            return self._find_missing_frames(self.dump.get(hash_data.hash))
+    def find_missing_mow_path_frames(self) -> list[int]:
+        """Find missing frames in current_mow_path based on total_frame."""
+        if not self.current_mow_path:
+            return []
 
-    def update(self, hash_data: NavGetCommDataAck) -> bool:
-        """Update the map data."""
-        if hash_data.type == PathType.AREA:
-            existing_name = next((area for area in self.area_name if area.hash == hash_data.hash), None)
-            if not existing_name:
-                self.area_name.append(AreaHashNameList(name=f"area {len(self.area_name)+1}", hash=hash_data.hash))
-            return self._add_hash_data(self.area, hash_data)
+        # Get total_frame from any MowPath object (they should all have the same total_frame)
+        total_frame = next(iter(self.current_mow_path.values())).total_frame
+
+        if total_frame == 0:
+            return []
+
+        if total_frame == len(self.current_mow_path):
+            return []
+
+        # Generate list of expected frame numbers (1 to total_frame)
+        expected_frames = set(range(1, total_frame + 1))
 
-        if hash_data.type == PathType.OBSTACLE:
-            return self._add_hash_data(self.obstacle, hash_data)
+        # Get current frame numbers from dictionary keys
+        current_frames = set(self.current_mow_path.keys())
 
-        if hash_data.type == PathType.PATH:
-            return self._add_hash_data(self.path, hash_data)
+        # Return sorted list of missing frames
+        missing_frames = sorted(expected_frames - current_frames)
+        return missing_frames
 
-        if hash_data.type == PathType.DUMP:
-            return self._add_hash_data(self.dump, hash_data)
+    def update_mow_path(self, path: MowPath) -> None:
+        """Update the current_mow_path with the latest MowPath data."""
+        # TODO check if we need to clear the current_mow_path first
+        self.current_mow_path[path.current_frame] = path
 
     @staticmethod
-    def _find_missing_frames(frame_list: FrameList | RootHashList) -> list[int]:
+    def find_missing_frames(frame_list: FrameList | RootHashList | None) -> list[int]:
+        if frame_list is None:
+            return []
+
         if frame_list.total_frame == len(frame_list.data):
             return []
         number_list = list(range(1, frame_list.total_frame + 1))
@@ -131,12 +420,59 @@ class HashList(DataClassORJSONMixin):
         return missing_numbers
 
     @staticmethod
-    def _add_hash_data(hash_dict: dict, hash_data: NavGetCommDataAck) -> bool:
-        if hash_dict.get(hash_data.hash) is None:
+    def _add_hash_data(hash_dict: dict[int, FrameList], hash_data: NavGetCommData | SvgMessage) -> bool:
+        if isinstance(hash_data, SvgMessage):
+            if hash_dict.get(hash_data.data_hash, None) is None:
+                hash_dict[hash_data.data_hash] = FrameList(total_frame=hash_data.total_frame, data=[hash_data])
+                return True
+
+            if hash_data not in hash_dict[hash_data.data_hash].data:
+                exists = next(
+                    (
+                        rhl
+                        for rhl in hash_dict[hash_data.data_hash].data
+                        if rhl.current_frame == hash_data.current_frame
+                    ),
+                    None,
+                )
+                if exists:
+                    return True
+                hash_dict[hash_data.data_hash].data.append(hash_data)
+                return True
+            return False
+
+        if hash_dict.get(hash_data.hash, None) is None:
             hash_dict[hash_data.hash] = FrameList(total_frame=hash_data.total_frame, data=[hash_data])
             return True
 
         if hash_data not in hash_dict[hash_data.hash].data:
+            exists = next(
+                (rhl for rhl in hash_dict[hash_data.hash].data if rhl.current_frame == hash_data.current_frame),
+                None,
+            )
+            if exists:
+                return True
             hash_dict[hash_data.hash].data.append(hash_data)
             return True
         return False
+
+    def invalidate_maps(self, bol_hash: int) -> None:
+        if MurMurHashUtil.hash_unsigned_list(self.area_root_hashlist) != bol_hash:
+            self.root_hash_lists = []
+
+    def generate_geojson(self, rtk: LocationPoint, dock: Dock) -> GeoJSONCollection:
+        """Generate geojson from frames."""
+        coordinator_converter = CoordinateConverter(rtk.latitude, rtk.longitude)
+        RTK_real_loc = coordinator_converter.enu_to_lla(0, 0)
+
+        dock_location = coordinator_converter.enu_to_lla(dock.latitude, dock.longitude)
+        dock_rotation = coordinator_converter.get_transform_yaw_with_yaw(dock.rotation) + 180
+
+        self.generated_geojson = generate_geojson(
+            self,
+            Point(RTK_real_loc.latitude, RTK_real_loc.longitude),
+            Point(dock_location.latitude, dock_location.longitude),
+            int(dock_rotation),
+        )
+
+        return self.generated_geojson

pymammotion/data/model/location.py

@@ -6,7 +6,7 @@ from mashumaro.mixins.orjson import DataClassORJSONMixin
 
 
 @dataclass
-class Point(DataClassORJSONMixin):
+class LocationPoint(DataClassORJSONMixin):
     """Returns a lat long."""
 
     latitude: float = 0.0
@@ -18,7 +18,7 @@ class Point(DataClassORJSONMixin):
 
 
 @dataclass
-class Dock(Point):
+class Dock(LocationPoint):
     """Stores robot dock position."""
 
     rotation: int = 0
@@ -28,8 +28,8 @@ class Dock(Point):
 class Location(DataClassORJSONMixin):
     """Stores/retrieves RTK GPS data."""
 
-    device: Point = field(default_factory=Point)
-    RTK: Point = field(default_factory=Point)
+    device: LocationPoint = field(default_factory=LocationPoint)
+    RTK: LocationPoint = field(default_factory=LocationPoint)
     dock: Dock = field(default_factory=Dock)
     position_type: int = 0
     orientation: int = 0  # 360 degree rotation +-

pymammotion/data/model/mowing_modes.py

@@ -10,6 +10,14 @@ class CuttingMode(IntEnum):
     no_grid = 3
 
 
+class CuttingSpeedMode(IntEnum):
+    """speed"""
+
+    normal = 0
+    slow = 1
+    fast = 2
+
+
 class BorderPatrolMode(IntEnum):
     """"""
 
@@ -37,13 +45,28 @@ class MowOrder(IntEnum):
     grid_first = 1
 
 
-class BypassStrategy(IntEnum):
+class TraversalMode(IntEnum):
+    """Traversal mode when returning."""
+
+    direct = 0
+    follow_perimeter = 1
+
+
+class TurningMode(IntEnum):
+    """Turning mode on corners."""
+
+    zero_turn = 0
+    multipoint = 1
+
+
+class DetectionStrategy(IntEnum):
     """Matches up with ultra_wave."""
 
     direct_touch = 0
     slow_touch = 1
     less_touch = 2
     no_touch = 10  # luba 2 yuka only or possibly value of 10
+    sensitive = 11  # x series
 
 
 class PathAngleSetting(IntEnum):