Wire IMU web stats to session rankings

Include supporting changes in TubStatistics, Tub, and web API
handler for IMU segment stats to use session rankings consistently.

Author: DocGarbanzo

donkeycar/parts/tub_statistics.py

@@ -129,7 +129,7 @@ class FieldAggregationSpec:
     output_key: str                      # e.g., 'gyro_z_agg'
     index: Optional[int] = None          # Vector index (None for scalars)
     transform: Optional[Callable] = None # Transform function
-    aggregation: str = 'avg'             # avg, sum, min, max, median
+    aggregation: str = 'avg'             # avg, sum, min, max, median, delta
 
     def extract(self, record: dict) -> Optional[float]:
         """Extract and transform value from record."""
@@ -170,6 +170,9 @@ def compute(self) -> Optional[float]:
             sorted_vals = sorted(self.values)
             mid = len(sorted_vals) // 2
             return sorted_vals[mid]
+        elif self.method == 'delta':
+            # Delta: last value - first value
+            return self.values[-1] - self.values[0]
         else:
             raise ValueError(f'Unknown aggregation method: {self.method}')
 

donkeycar/parts/tub_v2.py

@@ -25,7 +25,12 @@ def __init__(self, base_path, inputs=[], types=[], metadata=[],
         self.manifest = Manifest(base_path, inputs=inputs, types=types,
                                  metadata=metadata, max_len=max_catalog_len,
                                  read_only=read_only)
-        self.input_types = dict(zip(inputs, types))
+        # Use manifest inputs/types if parameters were not provided
+        if not inputs and not types:
+            self.input_types = dict(zip(self.manifest.inputs,
+                                       self.manifest.types))
+        else:
+            self.input_types = dict(zip(inputs, types))
         # Create images folder if necessary
         if not os.path.exists(self.images_base_path):
             os.makedirs(self.images_base_path, exist_ok=True)

donkeycar/parts/web_controller/web.py

@@ -137,6 +137,8 @@ def __init__(self, port=8887, mode='user'):
             (r"/wsTest", WsTest),
             (r"/imupath", IMUPathHandler),
             (r"/api/imupath/data", IMUPathDataAPI),
+            (r"/api/imupath/fields", IMUPathFieldsAPI),
+            (r"/api/imupath/stats", IMUPathStatsAPI),
             (r"/api/imupath/shutdown", IMUPathShutdownAPI),
 
             (r"/static/(.*)", StaticFileHandler,
@@ -410,6 +412,83 @@ async def get(self):
         await self.render("templates/imupath.html", **data)
 
 
+class IMUPathFieldsAPI(RequestHandler):
+    """
+    API endpoint for getting available fields from tub data.
+    Returns list of fields with metadata (type, dimensions, etc.)
+    """
+
+    async def get(self):
+        # Check if data is available
+        if self.application.imupath_builder is None:
+            self.set_status(404)
+            self.write({'error': 'No IMU path data loaded'})
+            return
+
+        try:
+            fields = self.application.imupath_builder.get_available_fields()
+            self.set_header('Content-Type', 'application/json')
+            self.write(json.dumps({'fields': fields}, ensure_ascii=False,
+                                 separators=(',', ':')))
+        except Exception as e:
+            logger.error(f"Error getting available fields: {e}",
+                        exc_info=True)
+            self.set_status(500)
+            self.write({'error': str(e)})
+
+
+class IMUPathStatsAPI(RequestHandler):
+    """
+    API endpoint for computing segment statistics on-demand.
+    Query parameters:
+        - field: Field name (required)
+        - method: Aggregation method (required)
+        - dimension: Vector component index (optional, for vector fields)
+    """
+
+    async def get(self):
+        # Check if data is available
+        if self.application.imupath_builder is None:
+            self.set_status(404)
+            self.write({'error': 'No IMU path data loaded'})
+            return
+
+        # Get query parameters
+        field_name = self.get_argument('field', default=None)
+        method = self.get_argument('method', default=None)
+        dimension_str = self.get_argument('dimension', default=None)
+
+        # Validate required parameters
+        if not field_name or not method:
+            self.set_status(400)
+            self.write({'error': 'Missing required parameters: field, method'})
+            return
+
+        # Parse dimension parameter
+        dimension = None
+        if dimension_str is not None and dimension_str != 'null' and dimension_str != '':
+            try:
+                dimension = int(dimension_str)
+            except ValueError:
+                self.set_status(400)
+                self.write({'error': 'Invalid dimension parameter: must be integer'})
+                return
+
+        try:
+            # Compute segment statistics
+            rankings = self.application.imupath_builder.compute_segment_statistics(
+                field_name, method, dimension)
+
+            self.set_header('Content-Type', 'application/json')
+            self.write(json.dumps({'rankings': rankings}, ensure_ascii=False,
+                                 separators=(',', ':')))
+        except Exception as e:
+            logger.error(f"Error computing segment statistics: {e}",
+                        exc_info=True)
+            self.set_status(500)
+            self.write({'error': str(e)})
+
+
 class IMUPathShutdownAPI(RequestHandler):
     """
     API endpoint to shutdown the server.