Update app.py

app.py

@@ -21,8 +21,17 @@ print(f"DOA Input: {model_doa.input_shape}, Output: {model_doa.output_shape}")
 
 SILENCE_CLASSES = [13, 14]
 VAD_SEGMENT_SIZE = 1024
-DOA_FEATURES = 34
-DOA_TIMESTEPS = 675
+
+# 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
 
 def predict_vad(audio_segment):
     if len(audio_segment) < VAD_SEGMENT_SIZE:
@@ -43,42 +52,108 @@ def predict_vad(audio_segment):
     
     return label, confidence, predicted_class
 
-def predict_doa(audio, sr):
+def extract_coarray_phases(multichannel_audio, sr=16000):
     """
-    Prediction DOA
-    Input attendu: (batch, 34, 675)
-    Output: (batch, 34) - angles ou probabilites
+    Extrait les phases du co-array pour le modele DOA.
+    Input: audio multicanal (n_channels, n_samples)
+    Output: (n_frames, 675) features
     """
-    # Extraire des features audio (MFCC ou autre)
-    # Le modele attend 34 features x 675 timesteps
+    n_channels = multichannel_audio.shape[0]
     
-    # Calculer MFCCs (34 coefficients)
-    n_mfcc = 34
-    mfccs = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=n_mfcc)
+    # 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)
     
-    # Ajuster la longueur temporelle a 675
-    if mfccs.shape[1] < DOA_TIMESTEPS:
-        mfccs = np.pad(mfccs, ((0, 0), (0, DOA_TIMESTEPS - mfccs.shape[1])), mode='constant')
-    else:
-        mfccs = mfccs[:, :DOA_TIMESTEPS]
+    # 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]
     
-    # Normaliser
-    mfccs = (mfccs - np.mean(mfccs)) / (np.std(mfccs) + 1e-8)
+    # 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')
     
-    # Reshape: (1, 34, 675)
-    features = mfccs.reshape(1, DOA_FEATURES, DOA_TIMESTEPS).astype(np.float32)
+    n_time_frames = stfts.shape[2]
+    features_list = []
     
-    # Prediction
-    prediction = model_doa.predict(features, verbose=0)
+    for t in range(n_time_frames):
+        frame_features = []
+        
+        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))
+            
+            # 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
+            
+            frame_features.extend([phase1, phase2, phase3])
+        
+        features_list.append(frame_features)
     
-    # Output: 34 valeurs - prendre l'indice max comme angle
-    # Supposons que les 34 sorties correspondent a des angles de -90 a +90 degres
-    angles = np.linspace(-90, 90, 34)
-    predicted_idx = int(np.argmax(prediction[0]))
-    predicted_angle = float(angles[predicted_idx])
-    confidence = float(np.max(prediction[0]))
+    features = np.array(features_list)  # (n_time_frames, 675)
+    return features
+
+def predict_doa(multichannel_audio, sr=16000):
+    """
+    Prediction DOA avec le modele CNN 1D.
+    Input: audio multicanal (n_channels, n_samples)
+    Output: angles predits
+    """
+    # Extraire les features co-array
+    features = extract_coarray_phases(multichannel_audio, sr)
+    
+    n_time_frames = features.shape[0]
     
-    return predicted_angle, confidence, prediction[0].tolist()
+    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
+    
+    # Prendre les 34 premieres trames (ou faire une moyenne sur plusieurs sequences)
+    all_angles = []
+    
+    n_sequences = max(1, n_time_frames // N_FRAMES)
+    
+    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
 
 @app.after_request
 def after_request(response):
@@ -89,13 +164,13 @@ def after_request(response):
 
 @app.route('/', methods=['GET'])
 def home():
-    return jsonify({'message': 'AcoustiTrack API', 'status': 'running', 'models': ['VAD', 'DOA']})
+    return jsonify({'message': 'AcoustiTrack API', 'status': 'running', 'models': ['VAD-CRNN', 'DOA-CNN1D']})
 
 @app.route('/api/health', methods=['GET', 'OPTIONS'])
 def health():
     if request.method == 'OPTIONS':
         return make_response('', 204)
-    return jsonify({'status': 'ok', 'model': 'CRNN VAD + CNN DOA'})
+    return jsonify({'status': 'ok', 'model': 'CRNN VAD + CNN1D DOA'})
 
 @app.route('/api/analyze', methods=['POST', 'OPTIONS'])
 def analyze():
@@ -108,12 +183,19 @@ def analyze():
         audio_file = request.files['audio']
         y, sr = librosa.load(io.BytesIO(audio_file.read()), sr=16000, mono=False)
         
+        # 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))
         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))])
         
-        n_channels = int(y.shape[0]) if y.ndim > 1 else 1
+        n_channels = int(y_multi.shape[0])
         duration = float(len(y_mono) / sr)
         
         # VAD prediction
@@ -154,19 +236,26 @@ 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
-        doa_angle, doa_confidence, doa_probs = predict_doa(y_mono, sr)
+        # DOA prediction (utilise audio multicanal)
+        doa_angle, doa_confidence, all_angles = predict_doa(y_multi, sr)
         
-        # DOA trajectory (based on segments)
+        # DOA trajectory
         doa_trajectory = []
-        for i, seg in enumerate(vad_timeline):
-            # Slight variation around predicted angle
-            angle_variation = doa_angle + np.random.randn() * 2
+        n_traj_points = min(len(all_angles), len(vad_timeline))
+        for i in range(n_traj_points):
             doa_trajectory.append({
-                'time': seg['start'],
-                'angle': float(round(angle_variation, 1))
+                '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))
             })
         
+        # 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))
         snr = float(round(10 * np.log10(mean_y / 1e-10), 1)) if mean_y > 0 else 0.0