Norway meetup violin - wip

Author: daslu

src/clojure_norway/meetup_2025_12/violin.clj

@@ -7,8 +7,8 @@
             [scicloj.tableplot.v1.plotly :as plotly]
             [tech.v3.tensor :as tensor]
             [tablecloth.column.api :as tcc]
-            [fastmath.stats :as stats]))
-
+            [fastmath.stats :as stats]
+            [tech.v3.datatype :as dtype]))
 
 ;; ## Data source
 ;;
@@ -86,7 +86,6 @@ wav-format
       (aset-short audio-shorts i (.getShort bb 0)))
     audio-shorts))
 
-
 (def wav-shorts
   (with-open [wav-stream (io/input-stream violin-file-path)]
     (audio-data wav-stream)))
@@ -95,29 +94,56 @@ wav-format
   ;; one of the two stereo channels
   (dfn// (->> wav-shorts
               (partition 2)
-              (map first))
+              (map first)
+              dtype/->double-array)
          32768.0))
 
-;; ## Listening to the data back as audio
+(def wav-ds
+  (tc/dataset
+   {:time (dfn// (range)
+                 (double sample-rate))
+    :sample wav-samples}))
 
+wav-ds
 
+(-> wav-ds
+    (tc/select-rows #(<= 0 (:time %) 1))
+    (plotly/layer-line {:=x :time
+                        :=y :sample}))
+
+(-> wav-ds
+    (tc/select-rows #(<= 1 (:time %) 1.06))
+    (plotly/layer-line {:=x :time
+                        :=y :sample}))
+
+;; ## Listening to the data back as audio
 
 ^kind/audio
 {:samples wav-samples
  :sample-rate sample-rate}
 
+^kind/audio
+{:samples (->> (-> wav-ds
+                   (tc/select-rows #(<= 1 (:time %) 1.06))
+                   :sample)
+               (repeat 30)
+               (apply concat))
+ :sample-rate sample-rate}
+
 ;; ## Computing the power spectrum of the data
 
 (import 'com.github.psambit9791.jdsp.transform.DiscreteFourier)
 
 (count wav-samples)
 
-(def first-part
-  (take sample-rate ; just a second
-        wav-samples))
+(def some-part
+  (->> wav-samples
+       (drop sample-rate) ; drop a second
+       (take (* sample-rate 0.06)) ; take 6% of a second
+       ))
 
 (def power-spectrum
-  (let [fft (-> first-part
+  (let [fft (-> some-part
                 double-array
                 DiscreteFourier.)]
     (.transform fft)
@@ -126,9 +152,12 @@ wav-format
 
 (count power-spectrum)
 
+(def Nyquist-freq (* 0.5 sample-rate))
+
 (def power-spectrum-ds
   (tc/dataset
-   {:freq (range)
+   {:freq (dfn// (range)
+                 (/ (count power-spectrum) Nyquist-freq))
     :power power-spectrum}))
 
 (-> power-spectrum-ds
@@ -145,7 +174,8 @@ wav-format
   (let [peaks (-> power-spectrum
                   FindPeak.
                   .detectPeaks)]
-    (-> (tc/dataset {:freq (.getPeaks peaks)
+    (-> (tc/dataset {:freq (dfn// (.getPeaks peaks)
+                                  (/ (count power-spectrum) Nyquist-freq ))
                      :power (.getHeights peaks)
                      :prominence (.getProminence peaks)})
         (tc/order-by [:prominence] :desc)
@@ -161,6 +191,7 @@ wav-format
 ;; ## Synthesizing from the peaks
 
 (require '[clojure.math :as math])
+(require '[tech.v3.datatype :as dtype])
 
 (def components-dataset
   (let [duration 1
@@ -191,130 +222,118 @@ wav-format
                         :=y :value
                         :=color :$column}))
 
+(defn normalize [values]
+  (tcc// values
+         (tcc/reduce-max (tcc/abs values))))
 
-(def violin-dataset
+(def combined-dataset
   (-> components-dataset
-      (tc/add-column :violin
+      (tc/add-column :combined
                      (fn [ds]
                        (-> ds
                            (tc/drop-columns [:time])
                            vals
-                           (->> (apply tcc/+)))))))
+                           (->> (apply tcc/+))
+                           normalize)))))
 
-(-> violin-dataset
+(-> combined-dataset
     (tc/head 200)
     (plotly/layer-line {:=x :time
-                        :=y :violin}))
+                        :=y :combined}))
 
 (defn audio [samples]
   (with-meta
     {:samples samples
      :sample-rate sample-rate}
     {:kind/audio true}))
 
-(defn normalize [values]
-  (tcc// values
-         (tcc/reduce-max (tcc/abs values))))
+(-> some-part
+    audio)
 
-(-> violin-dataset
-    :violin
-    normalize
+(-> combined-dataset
+    :combined
     audio)
 
-;; ## Power spectrum by part
-
-(require '[tech.v3.tensor :as tensor])
-
-(def parts
-  (let [n-parts 25]
-    (-> wav-samples
-        tensor/->tensor
-        (tensor/reshape  [n-parts
-                          (/ (count wav-samples) n-parts)])
-        (tensor/slice 1))))
-
-
-(def spectra
-  (->> parts
-       (pmap (fn [part]
-               (let [fft (-> part
-                             double-array
-                             DiscreteFourier.)]
-                 (.transform fft)
-                 ;; Get magnitude spectrum (power)
-                 (.getMagnitude fft true))))))
-
-(def spectra-ds
-  (->> spectra
-       (map (fn [s]
-              (tc/dataset
-               {:freq (range)
-                :power s})))))
-
-(->> spectra-ds
-     (map (fn [ds]
-            (-> ds
-                (plotly/base {:=height 300
-                              :=width 900})
-                (plotly/layer-line {:=x :freq
-                                    :=y :power})
-                plotly/plot
-                (assoc-in [:layout :xaxis :range] [0 1000])))))
-
-;; ## Peaks by part
-
-(def all-peaks-ds
-  (->> spectra
-       (map (fn [spectrum]
-              (let [peaks (-> spectrum
-                              FindPeak.
-                              .detectPeaks)]
-                (-> (tc/dataset {:freq (.getPeaks peaks)
-                                 :power (.getHeights peaks)
-                                 :prominence (.getProminence peaks)})
-                    (tc/order-by [:prominence] :desc)
-                    (tc/head n-peaks)))))))
-
-(map (fn [spectrum-ds peaks-ds]
-       (-> spectrum-ds
-           (plotly/base {:=x :freq
-                         :=y :power})
-           plotly/layer-line 
-           (plotly/layer-point {:=dataset peaks-ds})))
-     spectra-ds
-     all-peaks-ds)
+;; ## Spectogram (WIP)
+
+(import 'com.github.psambit9791.jdsp.windows.Hanning)
+(require '[tech.v3.dataset.tensor :as ds-tensor])
+
+(let [window-size 0.03 ; seconds
+      window-samples (* sample-rate window-size)
+
+      ;; Create Hanning window to reduce spectral leakage
+      hanning (-> window-samples
+                  Hanning.
+                  .getWindow
+                  dtype/as-reader)
+
+      ;; Overlap parameters
+      overlap-fraction 0.05
+      hop (int (* overlap-fraction window-samples))
+
+      n-samples (count wav-samples)
+
+      ;; Calculate how many windows we can extract
+      n-windows (-> n-samples
+                    (- window-samples)
+                    (quot hop))
+
+      ;; Create sliding windows: [time × windows × channels]
+      windows-shape [window-samples n-windows]
+      windows (tensor/compute-tensor
+               windows-shape
+               (fn [i j]
+                 ;; Extract sample at time i, window j, channel k
+                 (wav-samples (+ (* j hop) i)))
+               :float32)
+
+      ;; Apply Hanning window to each segment
+      hanninged-windows (tensor/compute-tensor
+                         windows-shape
+                         (fn [i j]
+                           (* (windows i j)
+                              (hanning i)))
+                         :float32)
+
+      ;; ;; Compute power spectrum for each window
+      spectogram (-> hanninged-windows
+                     ;; Rearrange to [windows × time]
+                     (tensor/transpose [1 0])
+                     (tensor/slice 1)
+                     ;; Apply FFT to each window
+                     (->> (pmap (fn [window]
+                                  (let [fft (-> window
+                                                dtype/as-reader
+                                                double-array
+                                                DiscreteFourier.)]
+                                    (.transform fft)
+                                    ;; Get magnitude spectrum (power)
+                                    (.getMagnitude fft true)))))
+                     tensor/->tensor
+                     ;; Reshape to [windows × frequencies]
+                     (#(tensor/reshape %
+                                       [n-windows
+                                        (-> % first count)]))
+                     ;; Transpose to [frequencies × windows] for plotting
+                     (tensor/transpose [1 0]))]
+  ;; (-> windows
+  ;;     (dfn/* 100)
+  ;;     plotly/imshow)
+
+  ;; (-> hanninged-windows
+  ;;     (dfn/* 100)
+  ;;     plotly/imshow)
+
+  (-> spectogram
+      (#(tensor/broadcast % (cons 3 (dtype/shape %))))
+      (dfn/* 50)
+      (tensor/transpose [1 2 0])
+      plotly/imshow))
+
+
+
+
 
-;; ## Synthesizing from the peaks
 
-(def combined-violin-ds
-  (->> all-peaks-ds
-       (map (fn [peaks-ds]
-              (let [duration (/ 3.0 25)
-                    num-samples (* duration sample-rate)
-                    time (dtype/make-reader :float32
-                                            num-samples
-                                            (/ idx sample-rate))]
-                (-> (->> (tc/rows peaks-ds :as-maps)
-                         ;; For each peak, generate a sine wave
-                         (map-indexed (fn [i {:keys [freq power]}]
-                                        [(str "wave" i)
-                                         (-> time
-                                             (dfn/* (* 2 math/PI freq))
-                                             dfn/sin
-                                             (dfn/* power))]))
-                         (into {:time time})
-                         tc/dataset)
-                    (tc/add-column :violin
-                                   (fn [ds]
-                                     (-> ds
-                                         (tc/drop-columns [:time])
-                                         vals
-                                         (->> (apply tcc/+)))))
-                    (tc/select-columns [:violin])))))
-       (apply tc/concat)))
-
-(-> combined-violin-ds
-    :violin
-    normalize
-    audio)