feat: enhance UI with additional filter controls and improved slider labels

app.py

@@ -393,99 +393,151 @@ with gr.Blocks() as demo:
             peq_plot = gr.Plot(
                 plot_eq(), label="PEQ Frequency Response", elem_id="peq-plot"
             )
-            with gr.Row():
-                with gr.Column():
-                    _ = gr.Markdown("Peak filter 1")
-                    pk1 = fx[0]
-                    pk1_freq = gr.Slider(
-                        minimum=33,
-                        maximum=5400,
-                        value=pk1.params.freq.item(),
-                        interactive=True,
-                    )
-                    pk1_gain = gr.Slider(
-                        minimum=-24,
-                        maximum=24,
-                        value=pk1.params.gain.item(),
-                        interactive=True,
-                    )
-                    pk1_q = gr.Slider(
-                        minimum=0.2,
-                        maximum=20,
-                        value=pk1.params.Q.item(),
-                        interactive=True,
-                    )
-                with gr.Column():
-                    _ = gr.Markdown("Peak filter 2")
-                    pk2 = fx[1]
-                    pk2_freq = gr.Slider(
-                        minimum=200,
-                        maximum=17500,
-                        value=pk2.params.freq.item(),
-                        interactive=True,
-                    )
-                    pk2_gain = gr.Slider(
-                        minimum=-24,
-                        maximum=24,
-                        value=pk2.params.gain.item(),
-                        interactive=True,
-                    )
-                    pk2_q = gr.Slider(
-                        minimum=0.2,
-                        maximum=20,
-                        value=pk2.params.Q.item(),
-                        interactive=True,
-                    )
-            with gr.Row():
-                with gr.Column():
-                    _ = gr.Markdown("Low Shelf")
-                    ls = fx[2]
-                    ls_freq = gr.Slider(
-                        minimum=30,
-                        maximum=200,
-                        value=ls.params.freq.item(),
-                        interactive=True,
-                    )
-                    ls_gain = gr.Slider(
-                        minimum=-24,
-                        maximum=24,
-                        value=ls.params.gain.item(),
-                        interactive=True,
-                    )
-                with gr.Column():
-                    _ = gr.Markdown("High Shelf")
-                    hs = fx[3]
-                    hs_freq = gr.Slider(
-                        minimum=750,
-                        maximum=8300,
-                        value=hs.params.freq.item(),
-                        interactive=True,
-                    )
-                    hs_gain = gr.Slider(
-                        minimum=-24,
-                        maximum=24,
-                        value=hs.params.gain.item(),
-                        interactive=True,
-                    )
-
-            comp_plot = gr.Plot(
-                plot_comp(), label="Compressor Curve", elem_id="comp-plot"
+    with gr.Row():
+        with gr.Column(min_width=160):
+            _ = gr.Markdown("High Pass")
+            hp = fx[5]
+            hp_freq = gr.Slider(
+                minimum=16,
+                maximum=5300,
+                value=hp.params.freq.item(),
+                interactive=True,
+                label="Frequency (Hz)",
             )
-            delay_plot = gr.Plot(
-                plot_delay(), label="Delay Frequency Response", elem_id="delay-plot"
+            hp_q = gr.Slider(
+                minimum=0.5,
+                maximum=10,
+                value=hp.params.Q.item(),
+                interactive=True,
+                label="Q",
             )
-            reverb_plot = gr.Plot(
-                plot_reverb(), label="Reverb Tone Correction PEQ", elem_id="reverb-plot"
+
+        with gr.Column(min_width=160):
+            _ = gr.Markdown("Low Shelf")
+            ls = fx[2]
+            ls_freq = gr.Slider(
+                minimum=30,
+                maximum=200,
+                value=ls.params.freq.item(),
+                interactive=True,
+                label="Frequency (Hz)",
+            )
+            ls_gain = gr.Slider(
+                minimum=-12,
+                maximum=12,
+                value=ls.params.gain.item(),
+                interactive=True,
+                label="Gain (dB)",
             )
-            t60_plot = gr.Plot(plot_t60(), label="Reverb T60", elem_id="t60-plot")
+
+        with gr.Column(min_width=160):
+            _ = gr.Markdown("Peak filter 1")
+            pk1 = fx[0]
+            pk1_freq = gr.Slider(
+                minimum=33,
+                maximum=5400,
+                value=pk1.params.freq.item(),
+                interactive=True,
+                label="Frequency (Hz)",
+            )
+            pk1_gain = gr.Slider(
+                minimum=-12,
+                maximum=12,
+                value=pk1.params.gain.item(),
+                interactive=True,
+                label="Gain (dB)",
+            )
+            pk1_q = gr.Slider(
+                minimum=0.2,
+                maximum=20,
+                value=pk1.params.Q.item(),
+                interactive=True,
+                label="Q",
+            )
+        with gr.Column(min_width=160):
+            _ = gr.Markdown("Peak filter 2")
+            pk2 = fx[1]
+            pk2_freq = gr.Slider(
+                minimum=200,
+                maximum=17500,
+                value=pk2.params.freq.item(),
+                interactive=True,
+                label="Frequency (Hz)",
+            )
+            pk2_gain = gr.Slider(
+                minimum=-12,
+                maximum=12,
+                value=pk2.params.gain.item(),
+                interactive=True,
+                label="Gain (dB)",
+            )
+            pk2_q = gr.Slider(
+                minimum=0.2,
+                maximum=20,
+                value=pk2.params.Q.item(),
+                interactive=True,
+                label="Q",
+            )
+
+        with gr.Column(min_width=160):
+            _ = gr.Markdown("High Shelf")
+            hs = fx[3]
+            hs_freq = gr.Slider(
+                minimum=750,
+                maximum=8300,
+                value=hs.params.freq.item(),
+                interactive=True,
+                label="Frequency (Hz)",
+            )
+            hs_gain = gr.Slider(
+                minimum=-12,
+                maximum=12,
+                value=hs.params.gain.item(),
+                interactive=True,
+                label="Gain (dB)",
+            )
+        with gr.Column(min_width=160):
+            _ = gr.Markdown("Low Pass")
+            lp = fx[4]
+            lp_freq = gr.Slider(
+                minimum=200,
+                maximum=18000,
+                value=lp.params.freq.item(),
+                interactive=True,
+                label="Frequency (Hz)",
+            )
+            lp_q = gr.Slider(
+                minimum=0.5,
+                maximum=10,
+                value=lp.params.Q.item(),
+                interactive=True,
+                label="Q",
+            )
+
+    comp_plot = gr.Plot(plot_comp(), label="Compressor Curve", elem_id="comp-plot")
+    delay_plot = gr.Plot(
+        plot_delay(), label="Delay Frequency Response", elem_id="delay-plot"
+    )
+    reverb_plot = gr.Plot(
+        plot_reverb(), label="Reverb Tone Correction PEQ", elem_id="reverb-plot"
+    )
+    t60_plot = gr.Plot(plot_t60(), label="Reverb T60", elem_id="t60-plot")
 
     with gr.Row():
         json_output = gr.JSON(
             model2json(), label="Effect Settings", max_height=800, open=True
         )
 
+    update_pc = lambda i: z[:NUMBER_OF_PCS].tolist() + [z[i - 1].item()]
+    update_pc_outputs = sliders + [extra_slider]
+
     for eq, s, attr_name in zip(
-        [fx[0]] * 3 + [fx[1]] * 3 + [fx[2]] * 2 + [fx[3]] * 2,
+        [fx[0]] * 3
+        + [fx[1]] * 3
+        + [fx[2]] * 2
+        + [fx[3]] * 2
+        + [fx[4]] * 2
+        + [fx[5]] * 2,
         [
             pk1_freq,
             pk1_gain,
@@ -497,163 +549,110 @@ with gr.Blocks() as demo:
             ls_gain,
             hs_freq,
             hs_gain,
+            lp_freq,
+            lp_q,
+            hp_freq,
+            hp_q,
         ],
-        ["freq", "gain", "Q"] * 2 + ["freq", "gain"] * 2,
+        ["freq", "gain", "Q"] * 2 + ["freq", "gain"] * 2 + ["freq", "Q"] * 2,
     ):
         s.input(
             lambda *args, eq=eq, attr_name=attr_name: chain_functions(  # chain_functions(
                 lambda args: (upatePEQ(eq, attr_name, args[0]), args[1]),
                 lambda args: (fx2z(), args[1]),
-                lambda args: [plot_eq()]
-                + z[:NUMBER_OF_PCS].tolist()
-                + [z[args[1] - 1].item(), model2json()],
+                lambda args: args[1],
+                lambda i: update_pc(i) + [model2json(), plot_eq()],
             )(
                 args
             ),
             inputs=[s, extra_pc_dropdown],
-            outputs=[peq_plot] + sliders + [extra_slider, json_output],
+            outputs=update_pc_outputs + [json_output, peq_plot],
         )
 
     render_button.click(
-        lambda *args: (
-            lambda x: (
-                x,
-                model2json(),
-                plot_eq(),
-                plot_comp(),
-                plot_delay(),
-                plot_reverb(),
-                plot_t60(),
-            )
-        )(inference(*args)),
+        # lambda *args: (
+        #     lambda x: (
+        #         x,
+        #         model2json(),
+        #     )
+        # )(inference(*args)),
+        inference,
         inputs=[
             audio_input,
-            # random_rest_checkbox,
-        ]
-        # + sliders,
-        ,
+        ],
         outputs=[
             audio_output,
-            json_output,
-            peq_plot,
-            comp_plot,
-            delay_plot,
-            reverb_plot,
-            t60_plot,
         ],
     )
 
+    update_fx = lambda: [
+        pk1.params.freq.item(),
+        pk1.params.gain.item(),
+        pk1.params.Q.item(),
+        pk2.params.freq.item(),
+        pk2.params.gain.item(),
+        pk2.params.Q.item(),
+        ls.params.freq.item(),
+        ls.params.gain.item(),
+        hs.params.freq.item(),
+        hs.params.gain.item(),
+        lp.params.freq.item(),
+        lp.params.Q.item(),
+        hp.params.freq.item(),
+        hp.params.Q.item(),
+    ]
+    update_fx_outputs = [
+        pk1_freq,
+        pk1_gain,
+        pk1_q,
+        pk2_freq,
+        pk2_gain,
+        pk2_q,
+        ls_freq,
+        ls_gain,
+        hs_freq,
+        hs_gain,
+        lp_freq,
+        lp_q,
+        hp_freq,
+        hp_q,
+    ]
+    update_plots = lambda: [
+        plot_eq(),
+        plot_comp(),
+        plot_delay(),
+        plot_reverb(),
+        plot_t60(),
+    ]
+    update_plots_outputs = [
+        peq_plot,
+        comp_plot,
+        delay_plot,
+        reverb_plot,
+        t60_plot,
+    ]
+
+    update_all = lambda i: update_pc(i) + update_fx() + update_plots()
+    update_all_outputs = update_pc_outputs + update_fx_outputs + update_plots_outputs
+
     random_button.click(
-        # lambda *xs: [
-        #     chain_functions(
-        #         partial(max, SLIDER_MIN),
-        #         partial(min, SLIDER_MAX),
-        #     )(normalvariate(0, 1))
-        #     for _ in range(len(xs))
-        # ],
-        # lambda i: (lambda x: x[:NUMBER_OF_PCS].tolist() + [x[i - 1].item()])(
-        #     z.normal_(0, 1).clip_(SLIDER_MIN, SLIDER_MAX)
-        # ),
         chain_functions(
             lambda i: (z.normal_(0, 1).clip_(SLIDER_MIN, SLIDER_MAX), i),
-            lambda args: args + (z2fx(),),
-            lambda args: args[0][:NUMBER_OF_PCS].tolist()
-            + [
-                args[0][args[1] - 1].item(),
-                model2json(),
-                plot_eq(),
-                plot_comp(),
-                plot_delay(),
-                plot_reverb(),
-                plot_t60(),
-            ]
-            + [
-                pk1.params.freq.item(),
-                pk1.params.gain.item(),
-                pk1.params.Q.item(),
-                pk2.params.freq.item(),
-                pk2.params.gain.item(),
-                pk2.params.Q.item(),
-                ls.params.freq.item(),
-                ls.params.gain.item(),
-                hs.params.freq.item(),
-                hs.params.gain.item(),
-            ],
+            lambda args: (z2fx(), args[1]),
+            lambda args: args[1],
+            update_all,
         ),
         inputs=extra_pc_dropdown,
-        outputs=sliders
-        + [
-            extra_slider,
-            json_output,
-            peq_plot,
-            comp_plot,
-            delay_plot,
-            reverb_plot,
-            t60_plot,
-        ]
-        + [
-            pk1_freq,
-            pk1_gain,
-            pk1_q,
-            pk2_freq,
-            pk2_gain,
-            pk2_q,
-            ls_freq,
-            ls_gain,
-            hs_freq,
-            hs_gain,
-        ],
+        outputs=update_all_outputs,
     )
     reset_button.click(
         # lambda: (lambda _: [0 for _ in range(NUMBER_OF_PCS + 1)])(z.zero_()),
         lambda: chain_functions(
             lambda _: z.zero_(),
             lambda _: z2fx(),
-            lambda _: [0 for _ in range(NUMBER_OF_PCS + 1)]
-            + [
-                model2json(),
-                plot_eq(),
-                plot_comp(),
-                plot_delay(),
-                plot_reverb(),
-                plot_t60(),
-            ]
-            + [
-                pk1.params.freq.item(),
-                pk1.params.gain.item(),
-                pk1.params.Q.item(),
-                pk2.params.freq.item(),
-                pk2.params.gain.item(),
-                pk2.params.Q.item(),
-                ls.params.freq.item(),
-                ls.params.gain.item(),
-                hs.params.freq.item(),
-                hs.params.gain.item(),
-            ],
+            lambda _: update_all(NUMBER_OF_PCS),
         )(None),
-        # inputs=sliders + [extra_slider],
-        outputs=sliders
-        + [
-            extra_slider,
-            json_output,
-            peq_plot,
-            comp_plot,
-            delay_plot,
-            reverb_plot,
-            t60_plot,
-        ]
-        + [
-            pk1_freq,
-            pk1_gain,
-            pk1_q,
-            pk2_freq,
-            pk2_gain,
-            pk2_q,
-            ls_freq,
-            ls_gain,
-            hs_freq,
-            hs_gain,
-        ],
+        outputs=update_all_outputs,
     )
 
     def update_z(s, i):
@@ -665,87 +664,19 @@ with gr.Blocks() as demo:
             chain_functions(
                 partial(update_z, i=i),
                 lambda _: z2fx(),
-                lambda _: (
-                    model2json(),
-                    plot_eq(),
-                    plot_comp(),
-                    plot_delay(),
-                    plot_reverb(),
-                    plot_t60(),
-                    pk1.params.freq.item(),
-                    pk1.params.gain.item(),
-                    pk1.params.Q.item(),
-                    pk2.params.freq.item(),
-                    pk2.params.gain.item(),
-                    pk2.params.Q.item(),
-                    ls.params.freq.item(),
-                    ls.params.gain.item(),
-                    hs.params.freq.item(),
-                    hs.params.gain.item(),
-                ),
+                lambda _: update_fx() + update_plots() + [model2json()],
             ),
             inputs=slider,
-            outputs=[
-                json_output,
-                peq_plot,
-                comp_plot,
-                delay_plot,
-                reverb_plot,
-                t60_plot,
-                pk1_freq,
-                pk1_gain,
-                pk1_q,
-                pk2_freq,
-                pk2_gain,
-                pk2_q,
-                ls_freq,
-                ls_gain,
-                hs_freq,
-                hs_gain,
-            ],
+            outputs=update_fx_outputs + update_plots_outputs + [json_output],
         )
     extra_slider.input(
         lambda *xs: chain_functions(
             lambda args: update_z(args[0], args[1] - 1),
             lambda _: z2fx(),
-            lambda _: (
-                model2json(),
-                plot_eq(),
-                plot_comp(),
-                plot_delay(),
-                plot_reverb(),
-                plot_t60(),
-                pk1.params.freq.item(),
-                pk1.params.gain.item(),
-                pk1.params.Q.item(),
-                pk2.params.freq.item(),
-                pk2.params.gain.item(),
-                pk2.params.Q.item(),
-                ls.params.freq.item(),
-                ls.params.gain.item(),
-                hs.params.freq.item(),
-                hs.params.gain.item(),
-            ),
+            lambda _: update_fx() + update_plots() + [model2json()],
         )(xs),
         inputs=[extra_slider, extra_pc_dropdown],
-        outputs=[
-            json_output,
-            peq_plot,
-            comp_plot,
-            delay_plot,
-            reverb_plot,
-            t60_plot,
-            pk1_freq,
-            pk1_gain,
-            pk1_q,
-            pk2_freq,
-            pk2_gain,
-            pk2_q,
-            ls_freq,
-            ls_gain,
-            hs_freq,
-            hs_gain,
-        ],
+        outputs=update_fx_outputs + update_plots_outputs + [json_output],
     )
 
     extra_pc_dropdown.input(