Development Page, Key Performance Indicators and Interface File Structure (#19)

* development box and drawer minimalization

* battery status in header bar

* manual steerer dialog styling

* dev_page and header_bar styling

* KPI-logging basics

* robot info dialog

* logging kpis of mowing

* kpi in status_drawer preparation

* kpi for automations

* main as router, restructuring interface folder, added pages files, kpi logic: kpi_generator, kpi_provider and kpi_page

* page routing, page_wrapper and dev_page

* conditional rendering depending on automation type

* fixing import error

* sorting rows error handled, join Y and Z axis info in status

* renamed UsbCamProvider to CalibratableCameraProvider

* added error kpis to dataclass, page route comment, fixed redundant check

Author: LukasBaecker

field_friend/automations/__init__.py

@@ -4,6 +4,7 @@
 from .coin_collecting import CoinCollecting
 from .coverage_planer import CoveragePlanner
 from .field_provider import Field, FieldObstacle, FieldProvider, Row
+from .kpi_provider import KpiProvider
 from .mowing import Mowing
 from .path_provider import Path, PathProvider
 from .path_recorder import PathRecorder

field_friend/automations/coin_collecting.py

@@ -21,6 +21,7 @@ def __init__(self, system: 'System') -> None:
         super().__init__()
         self.log = logging.getLogger('field_friend.coin_collecting')
         self.system = system
+        self.kpi_provider = system.kpi_provider
         self.work_x: float = 0.0
         self.front_x: float = 0.18
 
@@ -97,6 +98,7 @@ async def _weeding(self) -> None:
                         continue
                     except Exception as e:
                         self.log.exception(f'error while advancing on crop: {e}')
+                        self.kpi_provider.increment('automation_stopped')
                         break
                 if self.system.odometer.prediction.point.distance(Point(x=0, y=0)) > 0.1:
                     self.log.info('returning to start position')
@@ -107,6 +109,7 @@ async def _weeding(self) -> None:
                     await self.system.driver.drive_to(target)
                     already_explored = True  # avoid infinite loop if there are no crops
         finally:
+            self.kpi_provider.increment('coin_collecting_completed')
             await rosys.sleep(0.1)
             await self.system.field_friend.stop()
 

field_friend/automations/field_provider.py

@@ -1,13 +1,11 @@
 from dataclasses import dataclass, field
-from functools import lru_cache
 from statistics import mean
-from typing import Any, List, Literal, Optional, TypedDict, Union
+from typing import Any, Literal, Optional, TypedDict, Union
 
-import geopandas as gpd
 import rosys
 from geographiclib.geodesic import Geodesic
 from rosys.geometry import Point
-from shapely.geometry import LineString
+from shapely.geometry import LineString, Polygon
 
 from field_friend.navigation.point_transformation import wgs84_to_cartesian
 
@@ -198,6 +196,15 @@ def is_polygon(self, field: Field) -> bool:
     # the function need to be extended for more special cases
 
     def sort_rows(self, field: Field) -> None:
+        if len(field.rows) <= 1:
+            rosys.notify(f'There are not enough rows that can be sorted.', type='warning')
+            return
+
+        for row in field.rows:
+            if len(row.points_wgs84) < 1:
+                rosys.notify(f'Row {row.name} has to few points. Sorting not possible.', type='warning')
+                return
+
         def get_centroid(row: Row) -> Point:
             polyline = LineString(row.points_wgs84)
             return polyline.centroid

field_friend/automations/kpi_provider.py

@@ -0,0 +1,96 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+import rosys
+from rosys.analysis import KpiLogger
+
+from .plant_provider import PlantProvider
+
+
+@dataclass(slots=True, kw_only=True)
+class KPIs:
+    distance: int = 0
+    time: int = 0
+    bumps: int = 0
+    low_battery: int = 0
+    can_failure: int = 0
+    automation_stopped: int = 0
+    e_stop_triggered:  int = 0
+    soft_e_stop_triggered:  int = 0
+    imu_rolling_detected: int = 0
+    gnss_connection_lost: int = 0
+
+
+@dataclass(slots=True, kw_only=True)
+class Weeding_KPIs(KPIs):
+    rows_weeded: int = 0
+    crops_detected: int = 0
+    weeds_detected: int = 0
+    punches: int = 0
+    weeding_completed: bool = False
+
+
+@dataclass(slots=True, kw_only=True)
+class Mowing_KPIs(KPIs):
+    mowing_completed: bool = False
+
+
+class KpiProvider(KpiLogger):
+    def __init__(self, plant_provider: PlantProvider) -> None:
+        super().__init__()
+        self.plant_provider = plant_provider
+
+        self.plant_provider.ADDED_NEW_CROP.register(lambda: self.increment_weeding_kpi('crops_detected'))
+        self.plant_provider.ADDED_NEW_WEED.register(lambda: self.increment_weeding_kpi('weeds_detected'))
+
+        self.current_weeding_kpis: Weeding_KPIs = Weeding_KPIs()
+        self.WEEDING_KPIS_UPDATED = rosys.event.Event()
+        """one of the KPIs of the running weeding automation has been updated."""
+
+        self.current_mowing_kpis: Mowing_KPIs = Mowing_KPIs()
+        self.MOWING_KPIS_UPDATED = rosys.event.Event()
+        """one of the KPIs of the running mowing automation has been updated."""
+
+        self.needs_backup: bool = False
+
+    def backup(self) -> dict:
+        logger_backup = super().backup()
+        return {'current_weeding_kpis': rosys.persistence.to_dict(self.current_weeding_kpis),
+                'current_mowing_kpis': rosys.persistence.to_dict(self.current_mowing_kpis),
+                'days': logger_backup['days'],
+                'months': logger_backup['months']}
+
+    def restore(self, data: dict[str, Any]) -> None:
+        super().restore(data)
+        rosys.persistence.replace_dataclass(self.current_weeding_kpis, data.get('current_weeding_kpis', Weeding_KPIs()))
+        rosys.persistence.replace_dataclass(self.current_mowing_kpis, data.get('current_mowing_kpis', Mowing_KPIs()))
+
+    def invalidate(self) -> None:
+        self.request_backup()
+        self.WEEDING_KPIS_UPDATED.emit()
+        self.MOWING_KPIS_UPDATED.emit()
+
+    def increment_weeding_kpi(self, indicator: str) -> None:
+        self.increment(indicator)
+        new_value = getattr(self.current_weeding_kpis, indicator)+1
+        setattr(self.current_weeding_kpis, indicator, new_value)
+        self.WEEDING_KPIS_UPDATED.emit()
+        self.invalidate()
+        return
+
+    def increment_mowing_kpi(self, indicator: str) -> None:
+        self.increment(indicator)
+        new_value = getattr(self.current_mowing_kpis, indicator)+1
+        setattr(self.current_mowing_kpis, indicator, new_value)
+        self.MOWING_KPIS_UPDATED.emit()
+        self.invalidate()
+
+    def clear_weeding_kpis(self) -> None:
+        self.current_weeding_kpis = Weeding_KPIs()
+        self.WEEDING_KPIS_UPDATED.emit()
+        self.invalidate()
+
+    def clear_mowing_kpis(self) -> None:
+        self.current_mowing_kpis = Mowing_KPIs()
+        self.MOWING_KPIS_UPDATED.emit()
+        self.invalidate()

field_friend/automations/mowing.py

@@ -28,6 +28,7 @@ def __init__(self, system: 'System', *, robot_width: float) -> None:
         self.gnss = system.gnss
         self.system = system
         self.coverage_planner = CoveragePlanner(self)
+        self.kpi_provider = system.kpi_provider
 
         self.padding: float = 1.0
         self.lane_distance: float = 0.5
@@ -112,10 +113,12 @@ async def _mowing(self) -> None:
                         raise Exception('No paths to drive')
                 self.MOWING_STARTED.emit([path_segment for path in self.paths for path_segment in path])
                 await self._drive_mowing_paths(self.paths)
+                self.kpi_provider.increment_mowing_kpi('mowing_completed')
                 rosys.notify('Mowing finished', 'positive')
                 # break TODO: only for demo
             except Exception as e:
                 self.log.exception(e)
+                self.kpi_provider.increment('automation_stopped')
                 rosys.notify(f'Mowing failed because of {e}', 'negative')
                 break
 

field_friend/automations/plant_locator.py

@@ -2,7 +2,6 @@
 import logging
 
 import rosys
-
 from .plant_provider import Plant, PlantProvider
 
 WEED_CATEGORY_NAME = ['coin', 'weed']

field_friend/automations/plant_provider.py

@@ -33,8 +33,8 @@ def __init__(self) -> None:
         self.ADDED_NEW_WEED = rosys.event.Event()
         """A new weed has been added."""
 
-        self.ADDED_NEW_BEET = rosys.event.Event()
-        """A new beet has been added."""
+        self.ADDED_NEW_CROP = rosys.event.Event()
+        """A new crop has been added."""
 
         rosys.on_repeat(self.prune, 10.0)
 
@@ -73,7 +73,7 @@ def add_crop(self, crop: Plant) -> None:
                 return
         self.crops.append(crop)
         self.PLANTS_CHANGED.emit()
-        self.ADDED_NEW_BEET.emit()
+        self.ADDED_NEW_CROP.emit()
 
     def remove_crop(self, crop: Plant) -> None:
         self.crops[:] = [c for c in self.crops if c.id != crop.id]

field_friend/automations/puncher.py

@@ -3,7 +3,7 @@
 import rosys
 from rosys.driving import Driver
 from rosys.geometry import Point
-
+from .kpi_provider import KpiProvider
 from ..hardware import ChainAxis, FieldFriend, Tornado, YAxis, YAxisTornado, YAxisTornadoV2
 
 
@@ -12,9 +12,10 @@ class PuncherException(Exception):
 
 
 class Puncher:
-    def __init__(self, field_friend: FieldFriend, driver: Driver) -> None:
+    def __init__(self, field_friend: FieldFriend, driver: Driver, kpi_provider: KpiProvider) -> None:
         self.field_friend = field_friend
         self.driver = driver
+        self.kpi_provider = kpi_provider
         self.log = logging.getLogger('field_friend.puncher')
 
     async def try_home(self) -> bool:
@@ -85,6 +86,7 @@ async def punch(self, y: float, *, depth: float = 0.01, angle: float = 180) -> N
                 await self.field_friend.z_axis.move_to(depth)
                 await self.field_friend.z_axis.return_to_reference()
             self.log.info(f'punched successfully at {y:.2f} with depth {depth}')
+            self.kpi_provider.increment_weeding_kpi('punches')
         except Exception as e:
             raise PuncherException(f'punching failed because: {e}') from e
         finally:

field_friend/automations/weeding.py

@@ -28,6 +28,7 @@ def __init__(self, system: 'System') -> None:
 
         self.log = logging.getLogger('field_friend.weeding')
         self.system = system
+        self.kpi_provider = system.kpi_provider
 
         self.use_field_planning = True
         self.field: Optional[Field] = None
@@ -296,8 +297,10 @@ async def _weeding(self):
                 self.log.info('Planless weeding completed')
 
         except WorkflowException as e:
+            self.kpi_provider.increment('automation_stopped')
             self.log.error(f'WorkflowException: {e}')
         finally:
+            self.kpi_provider.increment_weeding_kpi('weeding_completed')
             await self.system.field_friend.stop()
             self.system.plant_locator.pause()
 

field_friend/interface/__init__.py

@@ -1,20 +1 @@
-from .automation_controls import automation_controls
-from .camera_card import camera_card
-from .development import development
-from .field_friend_object import field_friend_object
-from .field_object import field_object
-from .field_planner import field_planner
-from .hardware_control import hardware_control
-from .header_bar import header_bar
-from .key_controls import KeyControls
-from .leaflet_map import leaflet_map
-from .monitoring import monitoring
-from .operation import operation
-from .path_planner import path_planner
-from .plant_object import plant_objects
-from .robot_scene import robot_scene
-from .status_dev_page import status_dev_page
-from .status_drawer import status_drawer
-from .system_bar import system_bar
-from .test import test
-from .visualizer_object import visualizer_object
+from . import components, pages