THE UPDATE

app.py

@@ -84,6 +84,14 @@ with gr.Blocks() as main_ui:
                     )
                     fs_slider = gr.Slider(minimum=0, maximum=10000, value=1000, label="サンプリング周波数", step=10, info="単位はHz。")
                     column_dropdown = gr.Dropdown(["Fp1", "Fp2", "T7", "T8", "O1", "O2"], value="Fp2", label="使用する信号データ", allow_custom_value=True, info="使用する信号データを選んでください。デフォルトはFp2です。")
+                    integration_method = gr.Radio(
+                        ["Trapezoid(台形積分)", "Simpson(シンプソン法)"],
+                        label="Integration Method",
+                        value="Simpson(シンプソン法)",
+                    )
+                    segment_length = gr.Slider(minimum=0, maximum=8192, value=4096, step=1, label="STFT: セグメント長")
+                    overlap = gr.Slider(minimum=0, maximum=99, value=90, step=1, label="STFT: オーバーラップ率 [%]")
+                    fontsize = gr.Slider(minimum=0, maximum=20, value=12, step=1, label="グラフのフォントサイズ")
 
                 submit_button = gr.Button("計算開始")
 
@@ -94,6 +102,7 @@ with gr.Blocks() as main_ui:
                 )
 
             with gr.Column():
+                config_file = gr.File(label="Ziped Analyze File")
                 wavelet_image = gr.Image(type="filepath", label="Spectrogram")
                 band_intensity = gr.Image(type="filepath", label="Band Intensity")
                 signal_image = gr.Image(type="filepath", label="Signal")
@@ -101,8 +110,9 @@ with gr.Blocks() as main_ui:
         submit_button.click(spectrogram.generate_spectrogram_and_signal_plot, inputs=[
             file_input, analysis_method,
             fs_slider, fmax_slider, column_dropdown, start_time, end_time,
-            filter_setting, fp_hp, fs_hp, gpass, gstop, band_intensity_setting],
-            outputs=[wavelet_image, band_intensity, signal_image])
+            filter_setting, fp_hp, fs_hp, gpass, gstop, band_intensity_setting,
+            integration_method, segment_length, overlap, fontsize],
+            outputs=[wavelet_image, band_intensity, signal_image, config_file])
 
     with gr.Tab("1f noise analyze"):
         with gr.Row():

lab_tools/labutils.py

@@ -22,3 +22,29 @@ def load_signal(file_path, column_name):
     except KeyError as e:
         print(f"Column '{column_name}' not found in the file. ({e})", file=sys.stderr)
         return []
+
+
+def band_intensity_setting_to_band(input: str):
+    if "GAMMA" in input:
+        return (30, 36)
+    elif "BETA" in input:
+        return (15, 30)
+    elif "ALPHA" in input:
+        return (8, 12)
+    elif "THETA" in input:
+        return (4, 8)
+    elif "DELTA" in input:
+        return (0, 4)
+    else:
+        print("Unknown band")
+        return (None, None)
+
+
+def integration_method_to_method(input: str):
+    if "Trapezoid" in input:
+        return "trapz"
+    elif "Simpson" in input:
+        return "simps"
+    else:
+        print("Unknown method")
+        return None

lab_tools/spectrogram.py

@@ -1,32 +1,16 @@
+import math
+import os
+import yaml
+import subprocess
+import uuid
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.signal as signal
 from scipy.signal import fftconvolve
+from scipy.integrate import simpson, trapezoid
+import pandas as pd
 from lab_tools import labutils
 from lab_tools import filter
-import math
-import os
-
-
-def band_intensity_setting_to_band(input: str):
-    if "GAMMA" in input:
-        print("GAMMA")
-        return (30, 36)
-    elif "BETA" in input:
-        print("BETA")
-        return (15, 30)
-    elif "ALPHA" in input:
-        print("ALPHA")
-        return (8, 12)
-    elif "THETA" in input:
-        print("THETA")
-        return (4, 8)
-    elif "DELTA" in input:
-        print("DELTA")
-        return (0, 4)
-    else:
-        print("Unknown")
-        return (0, 0)
 
 
 # モルレーウェーブレットの計算
@@ -60,14 +44,14 @@ def perform_cwt(sample_rate, signal_data, max_frequency, wavelet_width=48, wavel
 
 
 # CWTの結果をプロットする関数
-def plot_cwt_result(cwt_matrix, time_array, max_frequency):
+def plot_cwt_result(cwt_matrix, time_array, max_frequency, fontsize=12):
     plt.subplots(figsize=(12, 6))
     plt.imshow(cwt_matrix, cmap='jet', aspect='auto',
                extent=[time_array[0], time_array[-1], max_frequency, 0],
                vmax=abs(cwt_matrix).max(), vmin=-abs(cwt_matrix).max())
-    plt.xlabel("Time [sec]")
-    plt.ylabel("Frequency [Hz]")
-    plt.colorbar(label="Power")
+    plt.xlabel("Time [sec]", fontsize=fontsize)
+    plt.ylabel("Frequency [Hz]", fontsize=fontsize)
+    plt.colorbar().set_label("Power", fontsize=fontsize)
     plt.clim(0, 5)
     plt.gca().invert_yaxis()
 
@@ -91,7 +75,7 @@ def perform_stft(signal_data, sample_rate: int, segment_length: int, overlap=0.5
 
 
 # 短時間フーリエ変換 (STFT) のスペクトログラムをプロットする関数
-def plot_stft_spectrogram(amplitude, frequencies, times, max_frequency=None):
+def plot_stft_spectrogram(amplitude, frequencies, times, max_frequency=None, fontsize=12):
     """
     Parameters:
         amplitude (np.ndarray): 信号強度データ
@@ -103,55 +87,194 @@ def plot_stft_spectrogram(amplitude, frequencies, times, max_frequency=None):
 
     fig, ax = plt.subplots(figsize=(12, 6))
     spectrogram = ax.pcolormesh(times, frequencies, amplitude, cmap='jet', shading="gourand", vmin=0, vmax=5)
-    fig.colorbar(spectrogram, ax=ax, orientation="vertical").set_label("Power")
-    ax.set_xlabel("Time [s]")
-    ax.set_ylabel("Frequency [Hz]")
+    fig.colorbar(spectrogram, ax=ax, orientation="vertical").set_label("Power", fontsize=fontsize)
+    ax.set_xlabel("Time [s]", fontsize=fontsize)
+    ax.set_ylabel("Frequency [Hz]", fontsize=fontsize)
 
     # 最大周波数の設定
     if max_frequency:
         ax.set_ylim([0, max_frequency])
 
 
-def plot_frequency_band_intensity(
-        time_array, frequency_array, analysis_matrix, freq_band, method="STFT",):
+def plot_signal(signal_data, time_data, start_time, end_time, fontsize, window_size=50):
+    smoothed_signal = np.convolve(signal_data, np.ones(window_size) / window_size, mode='valid')
+    trimmed_time_array = time_data[:len(smoothed_signal)]
+    plt.subplots(figsize=(12, 6))
+    plt.plot(trimmed_time_array, smoothed_signal)
+    plt.xlim(start_time, end_time)
+    plt.xlabel("Time [sec]", fontsize=fontsize)
+    plt.ylabel("Voltage [uV]", fontsize=fontsize)
+
+
+def calculate_frequency_band_intensity(
+        frequency_array, analysis_matrix, freq_band, method="STFT", integration_method="simps"):
     """
-    特定の周波数帯の強度変化をプロットする関数
+    特定の周波数帯の強度を計算する関数
 
     Parameters:
-        time_array (np.ndarray): 時間配列
         frequency_array (np.ndarray): 周波数配列 (STFT の場合は frequency、CWT の場合は range(max_frequency))
         analysis_matrix (np.ndarray): CWT または STFT の解析結果
-        freq_band (tuple): 表示する周波数帯 (例: (10, 20))
+        freq_band (tuple): 計算する周波数帯 (例: (10, 20))
         method (str): 解析手法 ("STFT" または "CWT")
+        integration_method (str): 数値積分の手法 ("trapz" または "simps")
+
+    Returns:
+        band_intensity (np.ndarray): 指定周波数帯域の強度の時間変化
     """
     # 周波数インデックスの範囲を取得
     freq_start, freq_end = freq_band
     if method == "STFT":
         freq_indices = np.where((frequency_array >= freq_start) & (frequency_array <= freq_end))[0]
+        freq_values = frequency_array[freq_indices]
     elif method == "CWT":
         freq_indices = range(freq_start, freq_end + 1)
+        freq_values = np.arange(freq_start, freq_end + 1)  # 仮の周波数配列
     else:
         raise ValueError("Invalid method. Use 'STFT' or 'CWT'.")
 
-    # 指定した周波数帯域の強度を平均化
-    band_intensity = analysis_matrix[freq_indices, :].mean(axis=0)
+    # 指定した周波数帯域の解析データを抽��
+    selected_matrix = analysis_matrix[freq_indices, :]
 
-    # プロット
-    plt.figure(figsize=(10, 5))
+    # 積分の実行
+    if integration_method == "trapz":
+        band_intensity = trapezoid(selected_matrix, x=freq_values, axis=0)
+    elif integration_method == "simps":
+        band_intensity = simpson(selected_matrix, x=freq_values, axis=0)
+    else:
+        raise ValueError("Invalid integration method. Use 'trapz' or 'simps'.")
+
+    return band_intensity
+
+
+def plot_frequency_band_intensity(
+        time_array, band_intensity, fontsize=12):
+    """
+    特定の周波数帯の強度変化をプロットする関数
+
+    Parameters:
+        time_array (np.ndarray): 時間配列
+        band_intensity (np.ndarray): 指定周波数帯域の強度の時間変化
+        freq_band (tuple): 表示する周波数帯 (例: (10, 20))
+        fontsize (int): プロットのフォントサイズ
+    """
+    plt.figure(figsize=(12, 6))
     plt.plot(time_array, band_intensity)
-    plt.xlabel("Time [sec]")
-    plt.ylabel("Power")
-    plt.title(f"Frequency Band Intensity ({freq_start}~{freq_end} Hz)")
-    plt.legend()
+    plt.xlabel("Time [sec]", fontsize=fontsize)
+    plt.ylabel("Integrated Power", fontsize=fontsize)
     plt.grid()
 
 
+def save_all_data_to_csv(
+        time_array, frequency_array, analysis_matrix, output_path, method="STFT", integration_method="simps"):
+    """
+    時間・周波数帯の解析データをCSVファイルに保存する関数 (pandasを使用)
+
+    Parameters:
+        time_array (np.ndarray): 時間配列
+        frequency_array (np.ndarray): 周波数配列
+        analysis_matrix (np.ndarray): STFTまたはCWTの解析結果
+        output_path (str): 保存先のCSVファイルパス
+        method (str): 解析手法 ("STFT" または "CWT")
+        integration_method (str): 数値積分の手法 ("trapz" または "simps")
+    """
+    # 各帯域の強度を計算
+    gamma = calculate_frequency_band_intensity(frequency_array, analysis_matrix, (30, 36), method, integration_method)
+    beta = calculate_frequency_band_intensity(frequency_array, analysis_matrix, (15, 30), method, integration_method)
+    alpha = calculate_frequency_band_intensity(frequency_array, analysis_matrix, (8, 12), method, integration_method)
+    theta = calculate_frequency_band_intensity(frequency_array, analysis_matrix, (4, 8), method, integration_method)
+    delta = calculate_frequency_band_intensity(frequency_array, analysis_matrix, (0, 4), method, integration_method)
+
+    # pandas DataFrameにまとめる
+    data = {
+        "Time [sec]": time_array,
+        "Gamma [30-36 Hz]": gamma,
+        "Beta [15-30 Hz]": beta,
+        "Alpha [8-12 Hz]": alpha,
+        "Theta [4-8 Hz]": theta,
+        "Delta [0-4 Hz]": delta
+    }
+    df = pd.DataFrame(data)
+
+    # CSVファイルに書き込み
+    df.to_csv(output_path, index=False)
+
+
+def export_arguments_to_yaml(
+        uploaded_file, analysis_method, sample_rate, max_frequency,
+        signal_column_name, start_time, end_time, filter_type,
+        highpass_cutoff, stopband_cutoff, passband_ripple, stopband_attenuation,
+        band_intensity_setting, integration_method, segment_length, overlap,
+        output_path="arguments.yaml"):
+    """
+    generate_spectrogram_and_signal_plotの引数をわかりやすい形式でYAMLに書き出す関数
+
+    Parameters:
+        各引数: generate_spectrogram_and_signal_plotの引数
+        output_path (str): 書き出すYAMLファイルのパス
+    """
+    arguments = {
+        "input_file": uploaded_file,  # アップロードされたファイル
+        "analysis": {
+            "method": analysis_method,  # 使用する解析手法
+            "sample_rate_hz": sample_rate,  # サンプリングレート
+            "max_frequency_hz": max_frequency,  # 最大周波数
+            "time_range_sec": {
+                "start": start_time,  # 開始時間
+                "end": end_time       # 終了時間
+            }
+        },
+        "signal_processing": {
+            "signal_column": signal_column_name,  # 信号データが格納された列名
+            "filter": {
+                "type": filter_type,  # フィルタタイプ (High Pass, Low Pass など)
+                "highpass_cutoff_hz": highpass_cutoff,  # ハイパスフィルタのカットオフ周波数
+                "stopband_cutoff_hz": stopband_cutoff,  # ストップバンドのカットオフ周波数
+                "passband_ripple_db": passband_ripple,  # パスバンドのリップル
+                "stopband_attenuation_db": stopband_attenuation  # ストップバンドの減衰量
+            }
+        },
+        "frequency_analysis": {
+            "band_of_interest": band_intensity_setting,  # 強度を解析する周波数帯 (例: Gamma, Beta など)
+            "integration_method": integration_method,  # 数値積分の手法 (Simpson, Trapezoidal など)
+        },
+        "stft_settings": {
+            "segment_length_samples": segment_length,  # セグメント長 (サンプル数)
+            "overlap_ratio": overlap  # セグメントのオーバーラップ率
+        }
+    }
+
+    # YAMLファイルに書き出し
+    with open(output_path, "w") as yaml_file:
+        yaml.dump(arguments, yaml_file, default_flow_style=False, allow_unicode=True)
+
+
+def zip_directory_with_command(directory_path, output_zip_path):
+    """
+    zipコマンドを使ってディレクトリを圧縮する関数。
+
+    Args:
+        directory_path (str): 圧縮するディレクトリのパス。
+        output_zip_path (str): 出力するzipファイルのパス。
+    """
+    try:
+        # zipコマンドを実行
+        subprocess.run(['zip', '-j', '-r', output_zip_path, directory_path], check=True)
+        print(f"{output_zip_path} に圧縮しました。")
+    except FileNotFoundError:
+        print("zipコマンドが見つかりません。インストールされているか確認してください。")
+    except subprocess.CalledProcessError as e:
+        print(f"zipコマンドの実行に失敗しました: {e}")
+
+    return output_zip_path
+
+
 # UI処理: スペクトログラム生成・信号プロット
 def generate_spectrogram_and_signal_plot(
         uploaded_file, analysis_method,
         sample_rate, max_frequency, signal_column_name, start_time, end_time,
         filter_type, highpass_cutoff, stopband_cutoff, passband_ripple, stopband_attenuation,
-        band_intensity_setting):
+        band_intensity_setting, integration_method, segment_length, overlap, fontsize):
+
     file_path = uploaded_file.name
     file_basename = os.path.basename(file_path)
 
@@ -159,7 +282,7 @@ def generate_spectrogram_and_signal_plot(
     if len(signal_data) == 0:
         return None, None
 
-    output_dir = "/tmp/spectrogram/"
+    output_dir = os.path.join("/tmp/spectrogram/", str(uuid.uuid1())[0:20].replace("-", ""))
     os.makedirs(output_dir, exist_ok=True)
 
     # フィルタ処理
@@ -182,55 +305,60 @@ def generate_spectrogram_and_signal_plot(
 
     # 信号プロットの保存
     window_size = 50
-    smoothed_signal = np.convolve(signal_data, np.ones(window_size) / window_size, mode='valid')
-    trimmed_time_array = time_array[:len(smoothed_signal)]
-
-    title = f"Signal(File: {file_basename}, Convolve Window Size: {window_size})"
-
     plt.figure(dpi=200)
-    plt.subplots(figsize=(12, 6))
-    plt.title(title)
-    plt.plot(trimmed_time_array, smoothed_signal)
-    plt.xlim(start_time, end_time)
-    plt.xlabel("Time [sec]")
-    plt.ylabel("Voltage [uV]")
+    plot_signal(signal_data, time_array, start_time, end_time, fontsize, window_size)
     signal_plot_path = os.path.join(output_dir, "signal_plot.png")
     plt.savefig(signal_plot_path)
 
-    freq_start, freq_end = band_intensity_setting_to_band(band_intensity_setting)
+    freq_start, freq_end = labutils.band_intensity_setting_to_band(band_intensity_setting)
+    integration_method = labutils.integration_method_to_method(integration_method)
+    overlap = float(overlap) / 100.0
 
     # スペクトログラムプロットの保存
     if analysis_method == "Short-Time Fourier Transform":
-        frequencies, times, amplitude = perform_stft(signal_data, sample_rate, 4096, 0.9)
+        frequencies, times, amplitude = perform_stft(signal_data, sample_rate, segment_length, overlap)
 
         plt.figure(dpi=200)
-        plot_stft_spectrogram(amplitude, frequencies, times, max_frequency)
+        plot_stft_spectrogram(amplitude, frequencies, times, max_frequency, fontsize)
         spectrogram_plot_path = os.path.join(output_dir, "stft_spectrogram_plot.png")
-        title = f"Spectrogram (File: {file_basename}, Method: STFT, Fs: {sample_rate} Hz, Segment Length: {4096}, Overlap: {0.9*100:.0f}%)"
-        plt.title(title)
         plt.savefig(spectrogram_plot_path)
 
         plt.figure(dpi=200)
-        plot_frequency_band_intensity(times, frequencies, amplitude, (freq_start, freq_end), method="STFT")
+        band_intensity = calculate_frequency_band_intensity(frequencies, amplitude, (freq_start, freq_end), method="STFT", integration_method=integration_method)
+        plot_frequency_band_intensity(times, band_intensity, fontsize=fontsize)
         plot_frequency_band_intensity_path = os.path.join(output_dir, "band_intensity.png")
-        title = f"Band Intensity (File: {file_basename}, {freq_start}~{freq_end} Hz Band Intensity)"
-        plt.title(title)
         plt.savefig(plot_frequency_band_intensity_path)
 
+        csv_path = os.path.join(output_dir, "band_intensity_data.csv")
+        save_all_data_to_csv(times, frequencies, amplitude, csv_path, method="STFT", integration_method=integration_method)
+
     else:
         spectrogram_plot_path = os.path.join(output_dir, "wavelet_spectrogram_plot.png")
         cwt_matrix = perform_cwt(sample_rate, signal_data, max_frequency)
         plt.figure(dpi=200)
-        plot_cwt_result(cwt_matrix, time_array, max_frequency)
-        title = f"Spectrogram (File: {file_basename}, Method: Wavelet, Fs: {sample_rate} Hz, Wavelet Width: {48})"
-        plt.title(title)
+        plot_cwt_result(cwt_matrix, time_array, max_frequency, fontsize)
         plt.savefig(spectrogram_plot_path)
 
         plt.figure(dpi=200)
-        plot_frequency_band_intensity(times, frequencies, amplitude, (freq_start, freq_end), method="CWT")
+        band_intensity = calculate_frequency_band_intensity(np.arange(max_frequency), cwt_matrix, (freq_start, freq_end), method="CWT", integration_method=integration_method)
+        plot_frequency_band_intensity(time_array, band_intensity, fontsize=fontsize)
         plot_frequency_band_intensity_path = os.path.join(output_dir, "band_intensity.png")
-        title = f"Band Intensity (File: {file_basename}, {freq_start}~{freq_end} Hz Band Intensity)"
-        plt.title(title)
         plt.savefig(plot_frequency_band_intensity_path)
 
-    return spectrogram_plot_path, plot_frequency_band_intensity_path, signal_plot_path
+        csv_path = os.path.join(output_dir, "band_intensity_data.csv")
+        save_all_data_to_csv(time_array, np.arange(max_frequency), cwt_matrix, csv_path, method="CWT", integration_method=integration_method)
+
+    config_yaml_path = os.path.join(output_dir, "lab_tool_spectrogram.yaml")
+
+    export_arguments_to_yaml(
+        file_basename, analysis_method,
+        sample_rate, max_frequency, signal_column_name, start_time, end_time,
+        filter_type, highpass_cutoff, stopband_cutoff, passband_ripple, stopband_attenuation,
+        band_intensity_setting, integration_method, segment_length, overlap,
+        config_yaml_path
+    )
+
+    os.remove('/tmp/all_analyze_file.zip')
+    ziped_file = zip_directory_with_command(output_dir, "/tmp/all_analyze_file.zip")
+
+    return spectrogram_plot_path, plot_frequency_band_intensity_path, signal_plot_path, ziped_file

unit_test.py

@@ -0,0 +1,45 @@
+# 必要なライブラリをインポート
+import numpy as np
+import matplotlib.pyplot as plt
+from lab_tools import spectrogram
+
+
+def spectrogram_test():
+    # パラメータ設定
+    Fs = 1000          # サンプリング周波数 (Hz)
+    duration = 5       # 信号の長さ（秒）
+    f0, f1 = 0, 50     # チャープ信号の開始・終了周波数
+    mod_freq = 1.0     # 振幅変調の周波数（Hz）
+    fmax = 50          # CWTの最大周波数
+
+    # 時間ベクトル
+    t = np.arange(0, duration, 1 / Fs)
+
+    # チャープ信号（0から50 Hzに周波数が変化）
+    chirp_signal = np.sin(2 * np.pi * ((f1 - f0) / duration * t**2 / 2 + f0 * t))
+
+    # 振幅変調（1 Hzの正弦波で振幅を変化させる）
+    modulation = (np.sin(2 * np.pi * mod_freq * t) + 1) / 0.2  # 0〜1の範囲にスケーリング
+    modulated_signal = chirp_signal * modulation
+
+    plt.figure(dpi=200)
+    plt.subplot(2, 1, 1)
+    spectrogram.plot_stft_spectrogram(modulated_signal, sample_rate=Fs, segment_length=512+256, overlap=0.99, max_frequency=fmax)
+    spectrogram_filename = "cwt_result.png"
+
+    plt.savefig(spectrogram_filename)
+
+    plt.figure(figsize=(12, 6))
+    plt.plot(t, modulated_signal, label="Amplitude Modulated Signal", color="orange")
+    plt.title("Amplitude Modulated Signal")
+    plt.xlabel("Time (s)")
+    plt.ylabel("Amplitude")
+    plt.grid()
+    plt.legend()
+
+    spectrogram_filename = "signal.png"
+    plt.savefig(spectrogram_filename)
+
+
+if __name__ == "__main__":
+    spectrogram_test()