Update ldq_percussion.py

ldq_percussion.py

@@ -19,25 +19,26 @@ def generate_kick(features: Dict[str, Any], sr: int, duration: float = 0.5) -> n
     area = cv2.contourArea(largest)
     perimeter = cv2.arcLength(largest, True)
     
-    # Fundamental frequency from contour area (30-60 Hz)
-    f0 = 30 + (area / 10000) * 30
-    # Modulation index from perimeter
-    mod_idx = 0.5 + (perimeter / 100) * 2.0
-    # Decay time from area
+    # Tuned for less buzz: lower modulation index
+    f0 = 30 + (area / 10000) * 30  # 30-60 Hz
+    mod_idx = 0.3 + (perimeter / 100) * 1.0  # Lower modulation
     decay = 0.3 + (area / 50000) * 0.4
     
     n = int(sr * duration)
     t = np.linspace(0, duration, n)
     
-    # FM synthesis: carrier = f0, modulator = f0 * 2
+    # FM synthesis with softer carrier
     carrier = np.sin(2 * np.pi * f0 * t)
     modulator = np.sin(2 * np.pi * f0 * 2 * t)
     kick = np.sin(2 * np.pi * f0 * t + mod_idx * modulator)
     
-    # Exponential decay
-    envelope = np.exp(-t * decay * 10)
+    # Exponential decay with longer tail
+    envelope = np.exp(-t * decay * 8)
     kick *= envelope
     
+    # Soft clipping to reduce harshness
+    kick = np.tanh(kick * 0.8) / np.tanh(0.8)
+    
     return kick
 
 def generate_snare(features: Dict[str, Any], sr: int, duration: float = 0.15) -> np.ndarray:
@@ -46,19 +47,8 @@ def generate_snare(features: Dict[str, Any], sr: int, duration: float = 0.15) ->
     if not lines:
         return np.zeros(int(sr * duration))
     
-    # Count intersections
-    intersections = []
-    for i in range(len(lines)):
-        for j in range(i+1, len(lines)):
-            x1, y1, x2, y2 = lines[i][0]
-            x3, y3, x4, y4 = lines[j][0]
-            # Simple intersection check (line segments)
-            # For brevity, we approximate with angle detection
-            pass
-    
-    # Approximate intersection count from line density
+    # Use low-frequency sawtooth with fast decay for a softer snare
     n_lines = len(lines)
-    intersection_count = max(1, int(n_lines * 0.5))
     
     # Center frequency from average line angle
     angles = []
@@ -67,14 +57,15 @@ def generate_snare(features: Dict[str, Any], sr: int, duration: float = 0.15) ->
         angle = math.degrees(math.atan2(y2-y1, x2-x1)) % 180
         angles.append(angle)
     avg_angle = np.mean(angles) if angles else 45
-    center_freq = 200 + (avg_angle / 180) * 200  # 200-400 Hz
+    center_freq = 150 + (avg_angle / 180) * 150  # 150-300 Hz (lower for less buzz)
     
-    # Bandpassed noise burst
-    noise = np.random.normal(0, 1, int(sr * duration))
-    # Simple bandpass approximation (for demo)
-    noise = noise * 0.5  # Reduce amplitude
-    envelope = np.exp(-np.linspace(0, duration, len(noise)) * 8)
-    snare = noise * envelope * 0.3
+    # Sawtooth with fast decay
+    n = int(sr * duration)
+    t = np.linspace(0, duration, n)
+    snare = np.sin(2 * np.pi * center_freq * t) * 0.5
+    snare += np.random.normal(0, 0.1, n)  # Small noise component
+    envelope = np.exp(-t * 15)
+    snare *= envelope
     
     return snare
 
@@ -95,17 +86,19 @@ def generate_hihats(features: Dict[str, Any], sr: int, bpm: float, duration: flo
     beats = duration * (bpm / 60)
     n_ticks = int(beats * subdivision)
     
-    # Amplitude from brightness
-    amp = 0.1 + brightness * 0.2
+    # Amplitude from brightness (reduced for less buzz)
+    amp = 0.05 + brightness * 0.1
     
     # Generate pulse train
     hihat = np.zeros(int(sr * duration))
     for i in range(n_ticks):
         pos = int(i * sr * 60 / (bpm * subdivision))
         if pos < len(hihat):
-            # Short square wave pulse
-            pulse_len = int(sr * 0.01)
+            # Short triangle wave pulse (smoother than square)
+            pulse_len = int(sr * 0.015)
             end = min(pos + pulse_len, len(hihat))
-            hihat[pos:end] += amp * 0.5
+            t_pulse = np.linspace(0, 0.015, pulse_len)
+            pulse = np.sin(2 * np.pi * 8000 * t_pulse) * amp * 0.3
+            hihat[pos:end] += pulse[:end-pos]
     
     return hihat