m

fft_just_do_it.py

@@ -4,36 +4,26 @@ def fft(signal, n=None):
     if n is None:
         n = len(signal)
 
-    # Згортка сигналу з комплексною експонентою
     return np.sum(signal * np.exp(-2j * np.pi * np.arange(n) / n)[:, None], axis=0)
 
 
 def stft(signal, window_length, hop_length):
-    # Розмір сигналу
     signal_length = len(signal)
 
-    # Кількість вікон STFT
     num_windows = 1 + (signal_length - window_length) // hop_length
 
-    # Ініціалізуємо масив для збереження результату STFT
     stft_result = np.zeros((num_windows, window_length), dtype=np.complex128)
 
-    # Цикл по вікнах
     for i in range(num_windows):
-        # Обчислюємо початок та кінець поточного вікна
         start = i * hop_length
         end = start + window_length
 
-        # Вирізаємо поточне вікно з сигналу
         windowed_signal = signal[start:end].astype(np.float64)
 
-        # Застосовуємо вікно Ханна (Hanning window)
         windowed_signal *= np.hanning(window_length)
 
-        # Обчислюємо швидке перетворення Фур'є (FFT)
         fft_result = np.fft.fft(windowed_signal)
 
-        # Записуємо результат FFT у відповідний рядок масиву stft_result
         stft_result[i, :] = fft_result
 
     return stft_result
@@ -66,33 +56,27 @@ def find_peaks(x, prominence=None, distance=None):
     right_bases = []
     prominences = []
 
-    # Find peaks
     for i in range(1, len(x) - 1):
         if x[i] > x[i - 1] and x[i] > x[i + 1]:
             peaks.append(i)
             peak_heights.append(x[i])
 
-    # Calculate left and right bases, and prominences
     for peak in peaks:
         left_base = peak
         right_base = peak
         prominence_value = x[peak]
 
-        # Find left base
         while left_base > 0 and x[left_base] <= x[left_base - 1]:
             left_base -= 1
         left_bases.append(left_base)
 
-        # Find right base
         while right_base < len(x) - 1 and x[right_base] <= x[right_base + 1]:
             right_base += 1
         right_bases.append(right_base)
 
-        # Calculate prominence
         prominence_value -= min(x[left_base], x[right_base])
         prominences.append(prominence_value)
 
-    # Apply prominence filter
     if prominence is not None:
         filtered_peaks = []
         filtered_peak_heights = []
@@ -114,7 +98,6 @@ def find_peaks(x, prominence=None, distance=None):
         right_bases = filtered_right_bases
         prominences = filtered_prominences
 
-    # Apply distance filter
     if distance is not None:
         filtered_peaks = [peaks[0]]
         filtered_peak_heights = [peak_heights[0]]

recording_script.py

@@ -0,0 +1,70 @@
+import tkinter as tk
+import pyaudio
+import wave
+from threading import Thread
+
+CHUNK = 1024
+FORMAT = pyaudio.paInt16
+CHANNELS = 1
+RATE = 44100
+RECORD_SECONDS = 10
+WAVE_OUTPUT_FILE = "output.wav"
+
+class RecorderApp:
+    def __init__(self, master):
+        self.master = master
+        self.master.title("Audio Recorder")
+
+        self.button = tk.Button(master, text="Tap to Record", command=self.start_recording, font=("Helvetica", 14), width=20, height=3)
+        self.button.pack(pady=20)
+
+        self.status_label = tk.Label(master, text="", font=("Helvetica", 14))
+        self.status_label.pack()
+
+        self.is_recording = False
+
+    def start_recording(self):
+        self.button.config(state=tk.DISABLED)
+        self.status_label.config(text="Listening to the tune...")
+        self.is_recording = True
+        Thread(target=self.record_audio).start()
+
+    def record_audio(self):
+        p = pyaudio.PyAudio()
+        stream = p.open(format=FORMAT,
+                        channels=CHANNELS,
+                        rate=RATE,
+                        input=True,
+                        frames_per_buffer=CHUNK)
+
+        frames = []
+        for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
+            if not self.is_recording:
+                break
+            data = stream.read(CHUNK)
+            frames.append(data)
+
+        stream.stop_stream()
+        stream.close()
+        p.terminate()
+
+        wf = wave.open(WAVE_OUTPUT_FILE, 'wb')
+        wf.setnchannels(CHANNELS)
+        wf.setsampwidth(p.get_sample_size(FORMAT))
+        wf.setframerate(RATE)
+        wf.writeframes(b''.join(frames))
+        wf.close()
+
+        self.status_label.config(text="Done!")
+        self.button.config(state=tk.NORMAL)
+
+    def stop_recording(self):
+        self.is_recording = False
+
+def main():
+    root = tk.Tk()
+    app = RecorderApp(root)
+    root.mainloop()
+
+if __name__ == "__main__":
+    main()