Added done Work

editing_data.py

@@ -0,0 +1,101 @@
+import numpy as np
+
+def detect_step_segments(signal, 
+                         diff_threshold=0.05, 
+                         min_length=20):
+    """
+    Erkennt automatisch Step-Up/Step-Down-Segmente aus einem gemessenen Tiefpass-Signal.
+    Arbeitet über die erste Ableitung statt über absolute Schwellen.
+    
+    signal : 1D array
+    diff_threshold : float  
+        Minimale Änderung pro Sample, um einen Step zu erkennen.
+        Für deine Daten funktioniert ~0.05 gut.
+    min_length : int  
+        Minimale Länge eines Segments (Samples).
+        
+    Returns:
+        list of (start_idx, end_idx)
+    """
+    
+    s = np.asarray(signal)
+    diff = np.diff(s)
+
+    # Step-Up dort, wo diff stark positiv ist
+    ups = np.where(diff > diff_threshold)[0]
+
+    # Step-Down dort, wo diff stark negativ ist
+    downs = np.where(diff < -diff_threshold)[0]
+
+    segments = []
+
+    # Beide Listen sind ungeordnet, aber Step-Up sollte vor Step-Down kommen
+    up_idx = 0
+    down_idx = 0
+
+    while up_idx < len(ups) and down_idx < len(downs):
+        start = ups[up_idx]
+
+        # Nimm das nächste Down-Event, das nach dem Start liegt
+        while down_idx < len(downs) and downs[down_idx] <= start:
+            down_idx += 1
+
+        if down_idx >= len(downs):
+            break
+
+        end = downs[down_idx]
+
+        if end - start >= min_length:
+            segments.append((start, end))
+
+        up_idx += 1
+        down_idx += 1
+
+    return merge_close_segments(segments)
+
+def merge_close_segments(segments, max_start_gap=10, max_end_gap=10):
+    """
+    Fasst Segmente zusammen, deren Starts und Ends nahe beieinander liegen.
+    
+    segments : list of (start, end)
+    max_start_gap : max Abstand zwischen Starts, um zusammenzufassen
+    max_end_gap   : max Abstand zwischen Ends, um zusammenzufassen
+
+    Returns:
+        merged list of (start, end)
+    """
+    if not segments:
+        return []
+
+    # Sortiere nach Start
+    segments = sorted(segments, key=lambda x: x[0])
+
+    merged = []
+    current_start, current_end = segments[0]
+
+    for start, end in segments[1:]:
+        # Prüfen, ob sowohl Start als auch End nah genug sind
+        if start - current_start <= max_start_gap and abs(end - current_end) <= max_end_gap:
+            # Segment gehört zum Cluster
+            current_end = max(current_end, end)
+        else:
+            merged.append((current_start, current_end))
+            current_start, current_end = start, end
+
+    merged.append((current_start, current_end))
+    return merged
+
+
+def laenge_laengstes_array(arrays):
+    """
+    Gibt die Länge des längsten Arrays in einem Array von Arrays zurück.
+
+    Parameters:
+    arrays (list of list or ndarray): Liste von Arrays
+
+    Returns:
+    int: Länge des längsten Arrays
+    """
+    # Konvertiere in ein NumPy-Array, um die Länge der inneren Arrays zu messen
+    laengen = np.array([len(a) for a in arrays])
+    return np.max(laengen)