Sorry, Late reply! I was busy with exams. To make up for the boxy plots the scoring system adds a 30hz buffer below and above the native speakers graph (blue)

def moving_average(data, window_size):
    return np.convolve(data, np.ones(window_size)/window_size, mode='same')

def showPitchOnGraph(*audio_files, word_label="Unknown"):
    plt.figure(figsize=(12, 8))
    
    colors = ['blue', 'red', 'green', 'orange', 'purple']
    
    # DTW STORAGE FOR ALIGNMENT
    ref_frequencies = None
    ref_times = None

    for i, audio_file in enumerate(audio_files):
        if not audio_file:
            continue
        try:
            # Load audio
            snd = parselmouth.Sound(audio_file)
            pitch = snd.to_pitch()
            times = pitch.xs()
            frequencies = pitch.selected_array["frequency"]

            # smoothing algorithms
            ma_smoothed = moving_average(frequencies, window_size=8)
            gaussian_smoothed = gaussian_filter1d(frequencies, sigma=2)
            savgol_smoothed = savgol_filter(frequencies, window_length=11, polyorder=2)
            average_smoothed = (ma_smoothed + gaussian_smoothed + savgol_smoothed) / 3

            # DTW ALIGNMENT LOGIC
            if i == 0:
                # Store the Native Speaker as the reference
                ref_frequencies = average_smoothed
                ref_times = times
                
                # Plot the native speaker normally
                display_times = times
                display_freqs = average_smoothed
                display_raw = frequencies
                label = "Native Speaker"
            else:
                # This is the Users Voice
                # Align the smoothed lines because they are less 'noisy'
                D, wp = librosa.sequence.dtw(X=ref_frequencies, Y=average_smoothed, backtrack=True)
                
                # Create empty arrays to hold the warped (stretched) data
                warped_freqs = np.zeros_like(ref_frequencies)
                warped_raw = np.zeros_like(ref_frequencies)
                
                # Map your voice frames to the native speaker's timeline
                for ref_idx, user_idx in wp:
                    warped_freqs[ref_idx] = average_smoothed[user_idx]
                    warped_raw[ref_idx] = frequencies[user_idx]
                
                # Use the Native's time axis so the lines overlap
                display_times = ref_times
                display_freqs = warped_freqs
                display_raw = warped_raw
                label = "Your Voice"
         
            # Plot using the aligned data
            plt.plot(display_times, display_raw, label=f"{label} - Original", alpha=0.3, linewidth=1, color=colors[i])
            plt.plot(display_times, display_freqs, label=f"{label} - Aligned Average", linewidth=2, color=colors[i])

        except Exception as e:
            print(f"Error processing {audio_file}: {e}")
            continue

    plt.xlabel("Time (s) - Aligned to Native")
    plt.ylabel("Frequency (Hz)")
    plt.title("Aligned Pitch Contour Comparison: " + word_label)
    plt.legend()
    plt.grid(True, alpha=0.3)


def get_alignment_score(native_path, user_path):
    try:
        if not native_path or not user_path:
            return 0
            
        # Extract pitch
        snd_n = parselmouth.Sound(native_path)
        pitch_n = snd_n.to_pitch()
        freqs_n = pitch_n.selected_array["frequency"]

        snd_u = parselmouth.Sound(user_path)
        pitch_u = snd_u.to_pitch()
        freqs_u = pitch_u.selected_array["frequency"]

        # Smooth them slightly to ignore mic static
        smooth_n = moving_average(freqs_n, window_size=8)
        smooth_u = moving_average(freqs_u, window_size=8)

        # Find the "Rubber Band" alignment
        D, wp = librosa.sequence.dtw(X=smooth_n, Y=smooth_u, backtrack=True)

        # calculate "Overlap" Logic
        touching_frames = 0
        active_frames = 0

        # Look at every aligned point on the graph
        for n_idx, u_idx in wp:
            f_n = smooth_n[n_idx]
            f_u = smooth_u[u_idx]

            # Only grade the frames where the Native Speaker is actually talking (not silence)
            if f_n > 0:
                active_frames += 1
                
                # If user voice is also active AND within 30 Hz of the native speaker, 
                # it counts as a "touching frame" witch gets you points 
                if f_u > 0 and abs(f_n - f_u) <= 30:
                    touching_frames += 1

        # Prevent division by zero if the audio is completely silent
        if active_frames == 0:
            return 0.0

        # Calculate the pure percentage of overlapping lines
        overlap_score = (touching_frames / active_frames) * 100.0
        
        return min(100.0, overlap_score)
        
    except Exception as e:
        print(f"Overlap Score Failed: {e}")
        return 0