Upload folder using huggingface_hub

processing_swipe.py

@@ -261,3 +261,105 @@ class SwipeProcessor(ProcessorMixin):
             Decoded string
         """
         return self.tokenizer.decode(token_ids, **kwargs)
+
+    def normalize_coordinates(
+        self, data_points: list[dict], canvas_width: float = None, canvas_height: float = None
+    ) -> 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(self, data_points: list[dict], max_len: int = None) -> 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 (defaults to self.max_path_len if not specified)
+
+        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
+        """
+        if max_len is None:
+            max_len = self.max_path_len
+
+        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