Update app.py

app.py

@@ -1,115 +1,110 @@
 import numpy as np
 import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from pydub import AudioSegment
+from scipy.fftpack import fft
 import streamlit as st
 import tempfile
 import os
-from pydub import AudioSegment
-from scipy.signal import get_window
-from scipy.fft import rfft, rfftfreq
-import plotly.express as px
+import subprocess
 
 # Define frequency ranges for musical notes based on 440Hz
 base_frequency = 440
 note_names = ["A", "A#", "B", "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#"]
+colors = plt.cm.hsv(np.linspace(0, 1, len(note_names)))
 
-def frequency_to_note(freq):
-    """周波数 freq がどのノートに近いかを返す関数。"""
-    if freq <= 0:
-        return None
-    # A4(=440Hz) をゼロとした半音インデックスを求める
-    semitone_index = int(round(12 * np.log2(freq / base_frequency)))
-    note_name = note_names[semitone_index % 12]
-    octave = 4 + (semitone_index // 12)
-    return f"{note_name}{octave}"
+# Map frequency to color based on 440Hz intervals
+def frequency_to_color(freq):
+    if freq < base_frequency / 2:
+        return "gray"  # Below audible range
+    
+    interval_index = int(np.log2(freq / base_frequency) * 12) % len(note_names)
+    return colors[interval_index]
 
+# Streamlit App
 def main():
-    st.title("スペクトログラム＆ピーク周波数可視化")
+    st.title("MP3 Fourier Transform Visualizer: ドレミドリブン")
 
     uploaded_file = st.file_uploader("音声ファイルをアップロード (MP3)", type=["mp3"])
-    
+
     if uploaded_file is not None:
         # Convert MP3 to WAV for easier processing
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_mp3:
             temp_mp3.write(uploaded_file.read())
             audio = AudioSegment.from_file(temp_mp3.name)
 
-        samples = np.array(audio.get_array_of_samples(), dtype=float)
+        samples = np.array(audio.get_array_of_samples())
         sample_rate = audio.frame_rate
 
-        # Convert stereo to mono if needed
+        # Normalize samples
         if audio.channels == 2:
             samples = samples.reshape((-1, 2))
-            samples = samples.mean(axis=1)
-
-        # Normalize to [-1, 1]
-        samples /= np.iinfo(audio.array_type).max
-
-        st.write(f"サンプリングレート: {sample_rate} Hz")
-        st.write(f"サンプル数: {len(samples)}")
-
-        # Parameters
-        chunk_size = st.sidebar.slider("FFTサイズ (Chunk Size)", min_value=1024, max_value=8192, value=2048, step=1024)
-        overlap = st.sidebar.slider("オーバーラップ (Overlap)", min_value=0, max_value=chunk_size-1, value=1024, step=256)
-        
-        window_type = st.sidebar.selectbox("ウィンドウ関数の種類", ["hann", "hamming", "blackman", "rect"])
-        if window_type == "rect":
-            window = np.ones(chunk_size)
-        else:
-            window = get_window(window_type, chunk_size)
-        
+            samples = samples.mean(axis=1)  # Convert to mono
+
+        # Define FFT parameters
+        chunk_size = 2048  # Number of samples per frame
+        overlap = 1024     # Overlap between frames
         step_size = chunk_size - overlap
-        freqs = rfftfreq(chunk_size, d=1/sample_rate)
-        
-        # Calculate number of chunks
-        n_chunks = (len(samples) - chunk_size) // step_size + 1
 
-        # Prepare array for spectrogram: shape (n_chunks, len(freqs))
-        spec_data = np.zeros((n_chunks, len(freqs)))
-        peak_freqs = []
+        # Calculate the FFT for each chunk
+        freqs = np.fft.rfftfreq(chunk_size, d=1/sample_rate)
+        n_chunks = (len(samples) - chunk_size) // step_size + 1
+        fft_frames = []
 
         for i in range(n_chunks):
-            start = i * step_size
-            end = start + chunk_size
-            chunk = samples[start:end] * window
-            
-            spec = np.abs(rfft(chunk))
-            spec_data[i, :] = spec
-            
-            # ピーク周波数を取得
-            peak_index = np.argmax(spec)
-            peak_frequency = freqs[peak_index]
-            peak_freqs.append(peak_frequency)
-
-        # フレームごとのピーク周波数をノート名に変換
-        peak_notes = [frequency_to_note(f) for f in peak_freqs]
-
-        # スペクトログラム描画 (plotly)
-        # spec_data: shape (time, frequency)
-        fig = px.imshow(
-            20 * np.log10(spec_data + 1e-8),  # dBスケールで可視化
-            origin='lower',
-            aspect='auto',
-            labels=dict(x="Time (frames)", y="Frequency Bin", color="Magnitude (dB)"),
-            color_continuous_scale='viridis'
-        )
-        st.plotly_chart(fig, use_container_width=True)
-
-        # ピーク周波数のラインプロット
-        time_axis = np.arange(n_chunks)
-        fig_peak = px.line(
-            x=time_axis, y=peak_freqs,
-            title="フレームごとのピーク周波数",
-            labels={"x":"Frame index", "y":"Peak Frequency (Hz)"}
-        )
-
-        # ピークノート（テキスト表示用）
-        note_text = [pn if pn is not None else "" for pn in peak_notes]
-        fig_peak.add_scatter(x=time_axis, y=peak_freqs, mode="text", text=note_text, textposition="top center")
-
-        st.plotly_chart(fig_peak, use_container_width=True)
-
-        # 一時ファイルの削除
+            chunk = samples[i * step_size:i * step_size + chunk_size]
+            windowed = chunk * np.hanning(len(chunk))
+            spectrum = np.abs(fft(windowed)[:len(freqs)])
+            fft_frames.append(spectrum)
+
+        fft_frames = np.array(fft_frames)
+
+        # Create animation with artistic elements
+        fig, ax = plt.subplots(facecolor="black")
+        line, = ax.plot(freqs, fft_frames[0], lw=2)
+        ax.set_xlim(0, np.max(freqs))
+        ax.set_ylim(0, np.max(fft_frames))
+        ax.set_xlabel("Frequency (Hz)", color="white")
+        ax.set_ylabel("Amplitude", color="white")
+        ax.set_title("音の周波数スペクトル", color="white")
+        ax.tick_params(colors="white")
+        fig.patch.set_facecolor("black")
+
+        # Highlight 440Hz intervals with vertical lines
+        for i in range(1, int(np.max(freqs) / base_frequency) + 1):
+            ax.axvline(i * base_frequency, color="white", linestyle="--", alpha=0.5)
+
+        def update(frame):
+            line.set_ydata(fft_frames[frame])
+            line.set_color(frequency_to_color(freqs[int(frame % len(freqs))]))
+            ax.set_facecolor(plt.cm.viridis(frame / len(fft_frames)))  # Dynamic background color
+            return line,
+
+        ani = FuncAnimation(fig, update, frames=len(fft_frames), blit=True)
+
+        # Save animation to a temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_video:
+            ani.save(temp_video.name, fps=30, extra_args=['-vcodec', 'libx264'])
+            video_path = temp_video.name
+
+        # Merge audio and video using ffmpeg
+        output_path = "output_art_video.mp4"
+        audio_path = tempfile.NamedTemporaryFile(delete=False, suffix=".wav").name
+        audio.export(audio_path, format="wav")
+
+        ffmpeg_command = [
+            "ffmpeg", "-y", "-i", video_path, "-i", audio_path, "-c:v", "copy", "-c:a", "aac", output_path
+        ]
+        subprocess.run(ffmpeg_command)
+
+        st.success("動画を生成しました！以下のリンクからダウンロードできます。")
+        with open(output_path, "rb") as file:
+            st.download_button(label="動画をダウンロード", data=file, file_name="output_art_video.mp4", mime="video/mp4")
+
+        # Cleanup temporary files
         os.remove(temp_mp3.name)
+        os.remove(video_path)
+        os.remove(audio_path)
 
 if __name__ == "__main__":
     main()