Delete preprocessing.py

preprocessing.py

@@ -1,108 +0,0 @@
-"""Standalone preprocessing utilities for swipe path data.
-
-This module provides preprocessing functions for the SwipeALot model that are
-completely standalone and don't require the full swipealot training package.
-"""
-
-import numpy as np
-
-
-def normalize_coordinates(
-    data_points: list[dict], canvas_width: float, canvas_height: float
-) -> list[dict]:
-    """
-    Normalize swipe coordinates and timestamps.
-
-    Args:
-        data_points: List of dicts with 'x', 'y', 't' keys
-        canvas_width: Canvas width (not used - kept for compatibility)
-        canvas_height: Canvas height (not used - kept for compatibility)
-
-    Returns:
-        List of normalized coordinate dicts with x, y in [0,1] and t in [0,1]
-
-    Note:
-        For futo-org/swipe.futo.org dataset, x and y are already normalized to [0,1].
-        This function clamps them to ensure they stay in bounds and normalizes timestamps.
-    """
-    if not data_points:
-        return []
-
-    # Extract timestamps for normalization
-    timestamps = [p["t"] for p in data_points]
-    t_min = min(timestamps)
-    t_max = max(timestamps)
-    t_range = t_max - t_min if t_max > t_min else 1.0
-
-    normalized = []
-    for point in data_points:
-        # x and y are already normalized to [0,1] in the dataset
-        # But sometimes they go slightly outside bounds, so clamp them
-        x_norm = max(0.0, min(1.0, point["x"]))
-        y_norm = max(0.0, min(1.0, point["y"]))
-
-        # Normalize timestamp to [0, 1]
-        t_norm = (point["t"] - t_min) / t_range
-
-        normalized.append({"x": x_norm, "y": y_norm, "t": t_norm})
-
-    return normalized
-
-
-def sample_path_points(data_points: list[dict], max_len: int) -> tuple:
-    """
-    Sample or pad path points to fixed length using linear interpolation.
-
-    Args:
-        data_points: List of coordinate dicts with 'x', 'y', 't' keys
-        max_len: Target length (typically 128 for SwipeALot models)
-
-    Returns:
-        Tuple of (sampled_points, mask) where:
-        - sampled_points: numpy array of shape [max_len, 3] with (x, y, t) coordinates
-        - mask: numpy array of shape [max_len] indicating valid (1) vs padding (0) points
-
-    Note:
-        - If path has fewer points than max_len, it's zero-padded
-        - If path has more points than max_len, it's downsampled using linear interpolation
-        - If path has exactly max_len points, it's returned as-is
-    """
-    num_points = len(data_points)
-
-    if num_points == max_len:
-        points = data_points
-        mask = [1] * max_len
-    elif num_points < max_len:
-        # Pad with zeros
-        points = data_points + [{"x": 0.0, "y": 0.0, "t": 0.0}] * (max_len - num_points)
-        mask = [1] * num_points + [0] * (max_len - num_points)
-    else:
-        # Downsample using linear interpolation
-        # Extract coordinates as arrays
-        x_coords = np.array([p["x"] for p in data_points])
-        y_coords = np.array([p["y"] for p in data_points])
-        t_coords = np.array([p["t"] for p in data_points])
-
-        # Original indices (parameter for interpolation)
-        original_indices = np.arange(num_points)
-
-        # Target indices for interpolation (evenly spaced)
-        target_indices = np.linspace(0, num_points - 1, max_len)
-
-        # Interpolate each coordinate independently
-        x_interp = np.interp(target_indices, original_indices, x_coords)
-        y_interp = np.interp(target_indices, original_indices, y_coords)
-        t_interp = np.interp(target_indices, original_indices, t_coords)
-
-        # Reconstruct points
-        points = [
-            {"x": float(x), "y": float(y), "t": float(t)}
-            for x, y, t in zip(x_interp, y_interp, t_interp, strict=True)
-        ]
-        mask = [1] * max_len
-
-    # Convert to numpy arrays
-    coords = np.array([[p["x"], p["y"], p["t"]] for p in points], dtype=np.float32)
-    mask = np.array(mask, dtype=np.int64)
-
-    return coords, mask