Update app.py

app.py

@@ -1,10 +1,11 @@
 from flask import Flask, request, jsonify, make_response
 from flask_cors import CORS
 import numpy as np
-import librosa
 import io
 import os
 import tensorflow as tf
+from scipy.io import wavfile
+from scipy.fft import fft
 
 app = Flask(__name__)
 CORS(app)
@@ -22,16 +23,42 @@ print(f"DOA Input: {model_doa.input_shape}, Output: {model_doa.output_shape}")
 SILENCE_CLASSES = [13, 14]
 VAD_SEGMENT_SIZE = 1024
 
-# DOA parameters
-STFT_WINDOW = 1024
-HOP_LENGTH = 512  # 50% overlap
-N_FFT = 1024
-SR = 16000
-FREQ_MIN = 500
-FREQ_MAX = 4000
-N_FRAMES = 34
-N_FREQ_BINS = 225
-N_PHASES = 3
+# DOA parameters (matching MATLAB code exactly)
+M = 4                    # nombre de microphones
+D_INTER = 0.02           # espacement 2cm
+WIN_LEN = 1024           # taille fenetre STFT
+HOP = 512                # hop size
+N_SNAPSHOTS = 10         # snapshots pour moyennage
+FS = 16000               # frequence echantillonnage
+N_BLOCKS = 34            # nombre de trames
+
+# Frequency bins 500-4000 Hz
+f_axis = np.arange(0, WIN_LEN // 2 + 1) * (FS / WIN_LEN)
+v_bins = np.where((f_axis >= 500) & (f_axis <= 4000))[0]
+N_BINS = len(v_bins)  # should be ~225
+
+# Co-array parameters for ULA with 4 mics
+# For ULA: differences are -3, -2, -1, 0, 1, 2, 3 (s=7)
+S = 2 * M - 1  # = 7 for 4 mics
+ZERO_IDX = M - 1  # = 3 (0-indexed: position of 0 in diffs)
+M_V = M  # = 4
+LEN_FEAT = S - 4  # = 3 (indices 4 to 6, i.e., indices 5:end in MATLAB 1-indexed)
+
+def get_coarray_indices(m):
+    """Generate co-array index mapping for ULA"""
+    # For ULA with m microphones, differences range from -(m-1) to (m-1)
+    # index_map[d] = list of (i,j) pairs where j-i = d
+    index_map = {}
+    for d in range(-(m-1), m):
+        pairs = []
+        for i in range(m):
+            for j in range(m):
+                if j - i == d:
+                    pairs.append((i, j))
+        index_map[d] = pairs
+    return index_map
+
+INDEX_MAP = get_coarray_indices(M)
 
 def predict_vad(audio_segment):
     if len(audio_segment) < VAD_SEGMENT_SIZE:
@@ -52,108 +79,83 @@ def predict_vad(audio_segment):
     
     return label, confidence, predicted_class
 
-def extract_coarray_phases(multichannel_audio, sr=16000):
+def extract_doa_features(au_data):
     """
-    Extrait les phases du co-array pour le modele DOA.
-    Input: audio multicanal (n_channels, n_samples)
-    Output: (n_frames, 675) features
+    Extract DOA features exactly as in MATLAB code.
+    au_data: (n_samples, 4) - 4 channel audio
+    Returns: (34, 225, 3) features
     """
-    n_channels = multichannel_audio.shape[0]
+    n_samples = au_data.shape[0]
     
-    # Calculer STFT pour chaque canal
-    stfts = []
-    for ch in range(n_channels):
-        S = librosa.stft(multichannel_audio[ch], n_fft=N_FFT, hop_length=HOP_LENGTH, win_length=STFT_WINDOW)
-        stfts.append(S)
-    stfts = np.array(stfts)  # (n_channels, n_freq, n_frames)
+    # Minimum length for 34 blocks
+    min_len = (N_BLOCKS * N_SNAPSHOTS * HOP) + WIN_LEN
     
-    # Frequences correspondantes
-    freqs = librosa.fft_frequencies(sr=sr, n_fft=N_FFT)
-    freq_mask = (freqs >= FREQ_MIN) & (freqs <= FREQ_MAX)
-    freq_indices = np.where(freq_mask)[0]
+    # Repeat if too short
+    if n_samples < min_len:
+        rep = int(np.ceil(min_len / n_samples))
+        au_data = np.tile(au_data, (rep, 1))
     
-    # Limiter a N_FREQ_BINS bins
-    if len(freq_indices) > N_FREQ_BINS:
-        freq_indices = freq_indices[:N_FREQ_BINS]
-    elif len(freq_indices) < N_FREQ_BINS:
-        # Padding si pas assez de bins
-        freq_indices = np.pad(freq_indices, (0, N_FREQ_BINS - len(freq_indices)), mode='edge')
+    # Take only min_len samples
+    au_data = au_data[:min_len, :]
     
-    n_time_frames = stfts.shape[2]
-    features_list = []
+    # Initialize features array (34, 225, 3)
+    frame_features = np.zeros((N_BLOCKS, N_BINS, LEN_FEAT))
     
-    for t in range(n_time_frames):
-        frame_features = []
+    for k in range(N_BLOCKS):
+        # Average covariance over snapshots
+        R_avg = np.zeros((M, M, N_BINS), dtype=complex)
         
-        for f_idx in freq_indices:
-            # Vecteur des signaux pour cette frequence et cette trame
-            x = stfts[:, f_idx, t]  # (n_channels,)
-            
-            # Matrice de covariance spatiale
-            R = np.outer(x, np.conj(x))
+        for snap in range(N_SNAPSHOTS):
+            idx_sample = k * N_SNAPSHOTS * HOP + snap * HOP
+            segment = au_data[idx_sample:idx_sample + WIN_LEN, :]  # (1024, 4)
             
-            # Extraire les phases du co-array (3 coefficients pour array lineaire 4 mics)
-            # Phases des elements hors-diagonale
-            if n_channels >= 2:
-                phase1 = np.angle(R[0, 1])  # Phase entre mic 0 et 1
-                phase2 = np.angle(R[0, 2]) if n_channels > 2 else 0.0
-                phase3 = np.angle(R[1, 2]) if n_channels > 2 else 0.0
-            else:
-                phase1, phase2, phase3 = 0.0, 0.0, 0.0
+            # FFT for each channel
+            X_f = fft(segment, n=WIN_LEN, axis=0)  # (1024, 4)
+            X_f = X_f[v_bins, :].T  # (4, 225) - transposed to match MATLAB
             
-            frame_features.extend([phase1, phase2, phase3])
+            for b in range(N_BINS):
+                vec_f = X_f[:, b]  # (4,) complex vector
+                norm_sq = np.linalg.norm(vec_f) ** 2 + 1e-10
+                R_avg[:, :, b] += np.outer(vec_f, np.conj(vec_f)) / norm_sq
         
-        features_list.append(frame_features)
+        R_avg /= N_SNAPSHOTS
+        
+        # Extract co-array phases
+        for b in range(N_BINS):
+            R = R_avg[:, :, b]
+            
+            # Build co-array vector z
+            z = np.zeros(S, dtype=complex)
+            jj = 0
+            for ii in range(-(M_V - 1), M_V):
+                pairs = INDEX_MAP.get(ii, [])
+                if pairs:
+                    z[jj] = np.mean([R[i, j] for i, j in pairs])
+                jj += 1
+            
+            # Extract phases from indices 4 to end (MATLAB: 5:s)
+            phases = np.angle(z[4:])  # indices 4, 5, 6 -> 3 values
+            frame_features[k, b, :] = phases
     
-    features = np.array(features_list)  # (n_time_frames, 675)
-    return features
+    return frame_features
 
-def predict_doa(multichannel_audio, sr=16000):
+def predict_doa(multichannel_audio):
     """
-    Prediction DOA avec le modele CNN 1D.
-    Input: audio multicanal (n_channels, n_samples)
-    Output: angles predits
+    Predict DOA angles using CNN model.
+    multichannel_audio: (n_samples, 4) array
+    Returns: list of 34 predicted angles
     """
-    # Extraire les features co-array
-    features = extract_coarray_phases(multichannel_audio, sr)
-    
-    n_time_frames = features.shape[0]
-    
-    if n_time_frames < N_FRAMES:
-        # Padding si pas assez de trames
-        padding = np.zeros((N_FRAMES - n_time_frames, features.shape[1]))
-        features = np.vstack([features, padding])
-        n_time_frames = N_FRAMES
+    # Extract features (34, 225, 3)
+    features = extract_doa_features(multichannel_audio)
     
-    # Prendre les 34 premieres trames (ou faire une moyenne sur plusieurs sequences)
-    all_angles = []
+    # Reshape to (1, 34, 675) - flatten last two dims
+    features_flat = features.reshape(1, N_BLOCKS, -1).astype(np.float32)
     
-    n_sequences = max(1, n_time_frames // N_FRAMES)
+    # Predict
+    prediction = model_doa.predict(features_flat, verbose=0)
+    angles = prediction[0].tolist()  # 34 angles
     
-    for seq_idx in range(min(n_sequences, 5)):  # Max 5 sequences pour la vitesse
-        start = seq_idx * N_FRAMES
-        end = start + N_FRAMES
-        
-        if end > n_time_frames:
-            break
-        
-        seq_features = features[start:end, :]  # (34, 675)
-        seq_features = seq_features.reshape(1, N_FRAMES, -1).astype(np.float32)
-        
-        # Prediction
-        prediction = model_doa.predict(seq_features, verbose=0)
-        angles = prediction[0]  # (34,) angles en degres
-        all_angles.extend(angles.tolist())
-    
-    if not all_angles:
-        return 0.0, 0.0, [0.0]
-    
-    # Angle moyen et confidence
-    mean_angle = float(np.mean(all_angles))
-    std_angle = float(np.std(all_angles))
-    confidence = float(max(0, 1 - std_angle / 60))  # Plus stable = plus confiant
-    
-    return mean_angle, confidence, all_angles
+    return angles
 
 @app.after_request
 def after_request(response):
@@ -181,25 +183,44 @@ def analyze():
             return jsonify({'error': 'Aucun fichier audio'}), 400
         
         audio_file = request.files['audio']
-        y, sr = librosa.load(io.BytesIO(audio_file.read()), sr=16000, mono=False)
+        audio_bytes = audio_file.read()
+        
+        # Read WAV file
+        sr, data = wavfile.read(io.BytesIO(audio_bytes))
+        
+        # Convert to float
+        if data.dtype == np.int16:
+            data = data.astype(np.float32) / 32768.0
+        elif data.dtype == np.int32:
+            data = data.astype(np.float32) / 2147483648.0
         
-        # Gerer mono vs multicanal
-        if y.ndim == 1:
-            y_mono = y
-            # Dupliquer pour creer 4 canaux (necessaire pour DOA)
-            y_multi = np.tile(y, (4, 1))
+        # Handle mono vs multi-channel
+        if data.ndim == 1:
+            # Mono - duplicate to 4 channels
+            data_multi = np.tile(data.reshape(-1, 1), (1, 4))
+            data_mono = data
         else:
-            y_mono = np.mean(y, axis=0)
-            y_multi = y
-            # S'assurer d'avoir 4 canaux
-            if y_multi.shape[0] < 4:
-                y_multi = np.vstack([y_multi, np.tile(y_multi[0:1], (4 - y_multi.shape[0], 1))])
+            data_multi = data
+            data_mono = np.mean(data, axis=1)
+            # Ensure 4 channels
+            if data_multi.shape[1] < 4:
+                data_multi = np.hstack([data_multi, np.tile(data_multi[:, 0:1], (1, 4 - data_multi.shape[1]))])
+            elif data_multi.shape[1] > 4:
+                data_multi = data_multi[:, :4]
         
-        n_channels = int(y_multi.shape[0])
-        duration = float(len(y_mono) / sr)
+        n_channels = data_multi.shape[1]
+        duration = len(data_mono) / sr
+        
+        # Resample to 16kHz if needed
+        if sr != FS:
+            from scipy.signal import resample
+            new_len = int(len(data_mono) * FS / sr)
+            data_mono = resample(data_mono, new_len)
+            data_multi = np.column_stack([resample(data_multi[:, i], new_len) for i in range(4)])
+            sr = FS
         
         # VAD prediction
-        total_segments = len(y_mono) // VAD_SEGMENT_SIZE
+        total_segments = len(data_mono) // VAD_SEGMENT_SIZE
         max_segments = min(total_segments, 20)
         if max_segments == 0:
             max_segments = 1
@@ -214,10 +235,10 @@ def analyze():
             start_sample = segment_index * VAD_SEGMENT_SIZE
             end_sample = start_sample + VAD_SEGMENT_SIZE
             
-            if end_sample > len(y_mono):
+            if end_sample > len(data_mono):
                 break
             
-            segment = y_mono[start_sample:end_sample]
+            segment = data_mono[start_sample:end_sample]
             label, confidence, _ = predict_vad(segment)
             
             if label == "voice":
@@ -236,27 +257,22 @@ def analyze():
         vad_label = "voice" if voice_ratio > 0.5 else "silence"
         avg_vad_confidence = float(np.mean(all_confidences)) if all_confidences else 0.0
         
-        # DOA prediction (utilise audio multicanal)
-        doa_angle, doa_confidence, all_angles = predict_doa(y_multi, sr)
+        # DOA prediction (uses 4-channel audio)
+        doa_angles = predict_doa(data_multi)
+        mean_angle = float(np.mean(doa_angles))
+        std_angle = float(np.std(doa_angles))
+        doa_confidence = float(max(0, 1 - std_angle / 25))
         
         # DOA trajectory
         doa_trajectory = []
-        n_traj_points = min(len(all_angles), len(vad_timeline))
-        for i in range(n_traj_points):
+        time_per_frame = duration / len(doa_angles)
+        for i, angle in enumerate(doa_angles):
             doa_trajectory.append({
-                'time': vad_timeline[i]['start'] if i < len(vad_timeline) else float(i * duration / n_traj_points),
-                'angle': float(round(all_angles[i] if i < len(all_angles) else doa_angle, 1))
+                'time': float(round(i * time_per_frame, 3)),
+                'angle': float(round(angle, 1))
             })
         
-        # Si pas assez de points, ajouter des points supplementaires
-        if len(doa_trajectory) < len(vad_timeline):
-            for i in range(len(doa_trajectory), len(vad_timeline)):
-                doa_trajectory.append({
-                    'time': vad_timeline[i]['start'],
-                    'angle': float(round(doa_angle + np.random.randn() * 2, 1))
-                })
-        
-        mean_y = float(np.mean(y_mono ** 2))
+        mean_y = float(np.mean(data_mono ** 2))
         snr = float(round(10 * np.log10(mean_y / 1e-10), 1)) if mean_y > 0 else 0.0
         
         return jsonify({
@@ -265,7 +281,7 @@ def analyze():
                 'channels': n_channels,
                 'sampleRate': int(sr),
                 'duration': float(round(duration, 2)),
-                'samples': int(len(y_mono)),
+                'samples': int(len(data_mono)),
                 'segments_analyzed': n_analyzed
             },
             'vad': {
@@ -274,14 +290,14 @@ def analyze():
                 'timeline': vad_timeline
             },
             'doa': {
-                'angle': float(round(doa_angle, 1)),
+                'angle': float(round(mean_angle, 1)),
                 'confidence': float(round(doa_confidence, 3)),
                 'trajectory': doa_trajectory
             },
             'metrics': {
                 'snr': snr,
                 'voiceRatio': float(round(voice_ratio, 2)),
-                'meanDoa': float(round(np.mean([d['angle'] for d in doa_trajectory]), 1))
+                'meanDoa': float(round(mean_angle, 1))
             }
         })
     except Exception as e: