flamo 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

flamo/auxiliary/reverb.py

@@ -67,7 +67,18 @@ class inverse_map_gamma(torch.nn.Module):
                 return y
             else:
                 return y**(1/self.delays)
-            
+
+class map_gfdn_gamma(torch.nn.Module):
+    def __init__(self, delays: torch.Tensor, n_groups: int, fs: int):
+        super().__init__()
+        self.delays = delays
+        self.n_groups = n_groups
+        self.fs = fs
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """Map input to grouped RT values."""
+        gamma = torch.mul(rt2slope(x, self.fs).unsqueeze(-1), self.delays.unsqueeze(0))
+        return gamma
 
 class HomogeneousFDN:
     r"""
@@ -281,7 +292,7 @@ class HomogeneousFDN:
             rt60, self.config_dict.sample_rate, torch.tensor(self.delays)
         ).squeeze()
         return 10 ** (gdB / 20)
-    
+
 
 class parallelFDNAccurateGEQ(dsp.parallelAccurateGEQ):
     r"""
@@ -371,6 +382,70 @@ class parallelFDNAccurateGEQ(dsp.parallelAccurateGEQ):
         self.input_channels = len(self.delays)
         self.output_channels = len(self.delays)
 
+class parallelGFDNAccurateGEQ(parallelFDNAccurateGEQ):
+    # TODO
+    def __init__(
+        self,
+        octave_interval: int = 1,
+        n_groups: int = 2,
+        nfft: int = 2**11,
+        fs: int = 48000,
+        delays: torch.Tensor =  None,
+        alias_decay_db: float = 0.0,
+        start_freq: float = 31.25,
+        end_freq: float = 16000.0,
+        device=None
+    ):
+        assert (delays is not None), "Delays must be provided"
+        self.delays = delays
+        map = map_gfdn_gamma(delays, n_groups, fs)
+        super().__init__(
+            size=( ),
+            octave_interval=octave_interval,
+            nfft=nfft,
+            delays=delays,
+            fs=fs,
+            map=map,
+            alias_decay_db=alias_decay_db,
+            start_freq=start_freq,
+            end_freq=end_freq,
+            device=device
+        )
+        self.n_gains = self.size[0]
+        self.size = (n_groups * self.size[0], len(delays))
+        self.param = param = torch.nn.Parameter(
+            torch.empty(self.size, device=self.device), requires_grad=self.requires_grad
+        )
+
+    def get_poly_coeff(self, param):
+        r"""
+        Computes the polynomial coefficients for the SOS section.
+        """
+        a = torch.zeros((3, self.size[0]+1, len(self.delays)), device=self.device)
+        b = torch.zeros((3, self.size[0]+1, len(self.delays)), device=self.device)
+        for n_i in range(len(self.delays)):
+            for i_group in range(self.n_gains):
+                (
+                    b[:, i_group * (self.n_gains) : (i_group + 1) * self.n_gains, n_i],
+                    a[:, i_group * (self.n_gains) : (i_group + 1) * self.n_gains, n_i],
+                ) = accurate_geq(
+                    target_gain=param[
+                        i_group * self.n_gains : (i_group + 1) * self.n_gains, n_i
+                    ],
+                    center_freq=self.center_freq,
+                    shelving_crossover=self.shelving_crossover,
+                    fs=self.fs,
+                    device=self.device,
+                )
+
+        b_aa = torch.einsum('p, pon -> pon', self.alias_envelope_dcy.to(torch.double), b.to(torch.double))
+        a_aa = torch.einsum('p, pon -> pon', self.alias_envelope_dcy.to(torch.double), a.to(torch.double))
+        B = torch.fft.rfft(b_aa, self.nfft, dim=0)
+        A = torch.fft.rfft(a_aa, self.nfft, dim=0)
+        H_temp = torch.prod(B, dim=1) / (torch.prod(A, dim=1))
+        H = torch.where(torch.abs(torch.prod(A, dim=1)) != 0, H_temp, torch.finfo(H_temp.dtype).eps*torch.ones_like(H_temp))
+        H_type = torch.complex128 if param.dtype == torch.float64 else torch.complex64
+        return H.to(H_type), B, A
 
 class parallelFDNGEQ(dsp.parallelGEQ):
     r"""
@@ -721,7 +796,6 @@ class parallelFDNPEQ(Filter):
         self.output_channels = len(self.delays)
 
 
-
 class parallelFirstOrderShelving(dsp.parallelFilter):
     
     def __init__(

flamo/functional.py

@@ -1,3 +1,4 @@
+import math
 import torch
 import torch.nn as nn
 import numpy as np
@@ -175,11 +176,12 @@ def signal_gallery(
         - ``sweep``: A linear sweep from 20 Hz to 20 kHz.
         - ``wgn``: White Gaussian noise.
         - ``exp``: An exponential decay signal.
+        - ``velvet``: A velvet noise signal with density :attr:`rate` impulses per second.
         - ``reference``: A reference signal provided as argument :attr:`reference`.
 
         **Arguments**:
             - **batch_size** (int): The number of batches to generate.
-            - **n_samples** (int): THe signal length in samples.
+            - **n_samples** (int): The signal length in samples.
             - **n_channel** (int): The number of channels in each signal.
             - **signal_type** (str, optional): The type of signal to generate. Defaults to 'impulse'.
             - **fs** (int, optional): The sampling frequency of the signals. Defaults to 48000.
@@ -198,6 +200,7 @@ def signal_gallery(
         "exp",
         "reference",
         "noise",
+        "velvet",
     }
 
     if signal_type not in signal_types:
@@ -243,6 +246,12 @@ def signal_gallery(
                 .expand(batch_size, n_samples, n)
                 .to(device)
             )
+        case "velvet":
+            x = torch.empty((batch_size, n_samples, n), device=device)
+            for i_batch in range(batch_size):
+                for i_ch in range(n):
+                    x[i_batch, :, i_ch] = gen_velvet_noise(n_samples, fs, rate, device)
+            return x
         case "reference":
             if isinstance(reference, torch.Tensor):
                 return reference.expand(batch_size, n_samples, n).to(device)
@@ -254,6 +263,38 @@ def signal_gallery(
             return torch.randn((batch_size, n_samples, n), device=device)
 
 
+def gen_velvet_noise(n_samples: int, fs: int, density: float, device: str | torch.device = None) -> torch.Tensor:
+    r"""
+    Generate a velvet noise sequence.
+    **Arguments**:
+        - **n_samples** (int): The length of the signal in samples.
+        - **fs** (int): The sampling frequency of the signal in Hz.
+        - **density** (float): The density of impulses in impulses per second.
+        - **device** (str | torch.device): The device of constructed tensors.
+    **Returns**:
+        - torch.Tensor: A tensor of shape (n_samples,) containing the velvet noise sequence.
+    """
+    Td = fs / density # average distance between impulses
+    num_impulses = n_samples / Td # expected number of impulses
+    floor_impulses = math.floor(num_impulses)
+    grid = torch.arange(floor_impulses) * Td
+
+    jitter_factors = torch.rand(floor_impulses)
+    impulse_indices = torch.ceil(grid + jitter_factors * (Td - 1)).long()
+
+    # first impulse is at position 0 and all indices are within bounds
+    impulse_indices[0] = 0
+    impulse_indices = torch.clamp(impulse_indices, max=n_samples - 1)
+            
+    # Generate random signs (+1 or -1)
+    signs = 2 * torch.randint(0, 2, (floor_impulses,)) - 1
+            
+    # Construct sparse signal
+    sequence = torch.zeros(n_samples, device=device)
+    sequence[impulse_indices] = signs.float()
+
+    return sequence
+
 def hertz2rad(hertz: torch.Tensor, fs: int):
     r"""
     Convert frequency from Hz to rad.

{flamo-0.1.6.dist-info → flamo-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamo
-Version: 0.1.6
+Version: 0.1.8
 Summary: An Open-Source Library for Frequency-Domain Differentiable Audio Processing
 Project-URL: Homepage, https://github.com/gdalsanto/flamo
 Project-URL: Issues, https://github.com/gdalsanto/flamo/issues

{flamo-0.1.6.dist-info → flamo-0.1.8.dist-info}/RECORD

@@ -1,11 +1,11 @@
 flamo/__init__.py,sha256=ujezWOJfD7DUoj4q1meeMUnB97rOEtNR7mYw_PE9LMg,49
-flamo/functional.py,sha256=9wl6fHkc8KMB5IMvbd_K7-z8Z2Miw0qOsNxWPItliPU,35138
+flamo/functional.py,sha256=8cKYzR5GDzH4ph4ja7x1znNFL-8ufWoxa666QHaZR1A,36917
 flamo/utils.py,sha256=ypGKSABZMphgIrjCKgCH-zgR7BaupRbyzuUhsZFqAAM,3350
 flamo/auxiliary/__init__.py,sha256=7lVNh8OxHloZ4KPmp-iTUJnUbi8XbuRzGaQ3Z-NKXio,42
 flamo/auxiliary/eq.py,sha256=eIWMIq0ggizXLhTdeWWbgBXWUFXCJyoEbkBH7Gzasao,6779
 flamo/auxiliary/filterbank.py,sha256=02w8dI8HoNDtKpdVhSJkIkd-h-KNXvZtivf3l4_ozzU,9866
 flamo/auxiliary/minimize.py,sha256=fMTAAAk9yD7Y4luKS4XA1-HTq44xo2opq_dRPRrhlIY,2474
-flamo/auxiliary/reverb.py,sha256=9iKSuyuqRiHGGvaj0eizqVpu2V7plsX13OWiB6o1whU,31636
+flamo/auxiliary/reverb.py,sha256=9c9aLRJCBnudNF3kefcf76HobFicrsxI3GcXyiOcYxo,34737
 flamo/auxiliary/scattering.py,sha256=qlK8cynrpde56yLlbPuScC0Y1VmsPb0SFXl6Xisv6hA,9420
 flamo/auxiliary/velvet.py,sha256=B4pYEnhaQPkh02pxqiGdAhLRX2g-eWtHezphi0_h4Qs,4201
 flamo/auxiliary/config/config.py,sha256=CxXj-8sLq0_m9KyLg1a6NwLoK1UvTz3i0jZOLraq14I,2893
@@ -18,7 +18,7 @@ flamo/optimize/utils.py,sha256=R5-KoZagRho3eykY88pC3UB2mc5SsE4Yv9X-ogskXdA,1610
 flamo/processor/__init__.py,sha256=paGdxGVZgA2VAs0tBwRd0bobzGxeyK79DS7ZGO8drkI,41
 flamo/processor/dsp.py,sha256=n92YJPrES-ydwHgXmZ9RkFevIC3n-Wh4X8I1QNZqcV0,126378
 flamo/processor/system.py,sha256=9XwLtaGEVs9glVOFvyiPnQpsnR_Wjrv6k1i1qCs8D1Q,42516
-flamo-0.1.6.dist-info/METADATA,sha256=n7uiBeQ1bqIP4Xwpmyx7Ah3FxCl2Xowucprz00lk2BM,7825
-flamo-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flamo-0.1.6.dist-info/licenses/LICENSE,sha256=smMocRH7xdPT5RvFNqSLtbSNzohXJM5G_rX1Qaej6vg,1120
-flamo-0.1.6.dist-info/RECORD,,
+flamo-0.1.8.dist-info/METADATA,sha256=a0hX9Mfk2wSUX7nPKwesQ6WYnmpgSUNpf_iBitMz2iA,7825
+flamo-0.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flamo-0.1.8.dist-info/licenses/LICENSE,sha256=smMocRH7xdPT5RvFNqSLtbSNzohXJM5G_rX1Qaej6vg,1120
+flamo-0.1.8.dist-info/RECORD,,