torchrir 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

torchrir/datasets/librispeech.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+"""LibriSpeech dataset helpers."""
+
+import logging
+import tarfile
+import urllib.request
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Tuple
+
+import torch
+
+from .base import BaseDataset
+from .utils import load_wav_mono
+
+BASE_URL = "https://www.openslr.org/resources/12"
+VALID_SUBSETS = {
+    "dev-clean",
+    "dev-other",
+    "test-clean",
+    "test-other",
+    "train-clean-100",
+    "train-clean-360",
+    "train-other-500",
+}
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LibriSpeechSentence:
+    """Sentence metadata from LibriSpeech."""
+
+    utterance_id: str
+    text: str
+    speaker_id: str
+    chapter_id: str
+
+
+class LibriSpeechDataset(BaseDataset):
+    """LibriSpeech dataset loader.
+
+    Example:
+        >>> dataset = LibriSpeechDataset(Path("datasets/librispeech"), subset="train-clean-100", download=True)
+        >>> audio, fs = dataset.load_wav("103-1240-0000")
+    """
+
+    def __init__(
+        self, root: Path, subset: str = "train-clean-100", download: bool = False
+    ) -> None:
+        """Initialize a LibriSpeech dataset handle.
+
+        Args:
+            root: Root directory where the dataset is stored.
+            subset: LibriSpeech subset name (e.g., "train-clean-100").
+            download: Download and extract if missing.
+        """
+        if subset not in VALID_SUBSETS:
+            raise ValueError(f"unsupported subset: {subset}")
+        self.root = Path(root)
+        self.subset = subset
+        self._archive_name = f"{subset}.tar.gz"
+        self._base_dir = self.root / "LibriSpeech"
+        self._subset_dir = self._base_dir / subset
+
+        if download:
+            self._download_and_extract()
+
+        if not self._subset_dir.exists():
+            raise FileNotFoundError(
+                "dataset not found; run with download=True or place the archive under "
+                f"{self.root}"
+            )
+
+    def list_speakers(self) -> List[str]:
+        """Return available speaker IDs."""
+        if not self._subset_dir.exists():
+            return []
+        return sorted([p.name for p in self._subset_dir.iterdir() if p.is_dir()])
+
+    def available_sentences(self) -> List[LibriSpeechSentence]:
+        """Return sentences that have a corresponding audio file."""
+        sentences: List[LibriSpeechSentence] = []
+        for trans_path in self._subset_dir.rglob("*.trans.txt"):
+            chapter_dir = trans_path.parent
+            speaker_id = chapter_dir.parent.name
+            chapter_id = chapter_dir.name
+            with trans_path.open("r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    utt_id, text = _parse_text_line(line)
+                    wav_path = chapter_dir / f"{utt_id}.flac"
+                    if wav_path.exists():
+                        sentences.append(
+                            LibriSpeechSentence(
+                                utterance_id=utt_id,
+                                text=text,
+                                speaker_id=speaker_id,
+                                chapter_id=chapter_id,
+                            )
+                        )
+        return sentences
+
+    def load_wav(self, utterance_id: str) -> Tuple[torch.Tensor, int]:
+        """Load a mono wav for the given utterance ID."""
+        speaker_id, chapter_id, _ = utterance_id.split("-", 2)
+        path = self._subset_dir / speaker_id / chapter_id / f"{utterance_id}.flac"
+        return load_wav_mono(path)
+
+    def _download_and_extract(self) -> None:
+        """Download and extract the subset archive if needed."""
+        self.root.mkdir(parents=True, exist_ok=True)
+        archive_path = self.root / self._archive_name
+        url = f"{BASE_URL}/{self._archive_name}"
+
+        if not archive_path.exists():
+            logger.info("Downloading %s", url)
+            _download(url, archive_path)
+        if not self._subset_dir.exists():
+            logger.info("Extracting %s", archive_path)
+            try:
+                with tarfile.open(archive_path, "r:gz") as tar:
+                    tar.extractall(self.root)
+            except (tarfile.ReadError, EOFError, OSError) as exc:
+                logger.warning("Extraction failed (%s); re-downloading.", exc)
+                if archive_path.exists():
+                    archive_path.unlink()
+                _download(url, archive_path)
+                with tarfile.open(archive_path, "r:gz") as tar:
+                    tar.extractall(self.root)
+
+
+def _download(url: str, dest: Path, retries: int = 1) -> None:
+    """Download a file with retry and resume-safe temp file."""
+    for attempt in range(retries + 1):
+        try:
+            _stream_download(url, dest)
+            return
+        except Exception as exc:
+            if dest.exists():
+                dest.unlink()
+            if attempt >= retries:
+                raise
+            logger.warning("Download failed (%s); retrying...", exc)
+
+
+def _stream_download(url: str, dest: Path) -> None:
+    """Stream a URL to disk with a progress indicator."""
+    tmp_path = dest.with_suffix(dest.suffix + ".part")
+    if tmp_path.exists():
+        tmp_path.unlink()
+
+    with urllib.request.urlopen(url) as response:
+        total = response.length or 0
+        downloaded = 0
+        chunk_size = 1024 * 1024
+        with tmp_path.open("wb") as f:
+            while True:
+                chunk = response.read(chunk_size)
+                if not chunk:
+                    break
+                f.write(chunk)
+                downloaded += len(chunk)
+    if total > 0 and downloaded != total:
+        raise IOError(f"incomplete download: {downloaded} of {total} bytes")
+    tmp_path.replace(dest)
+
+
+def _parse_text_line(line: str) -> Tuple[str, str]:
+    """Parse a LibriSpeech transcript line into (utterance_id, text)."""
+    left, _, right = line.partition(" ")
+    return left, right.strip()

torchrir/datasets/template.py

@@ -34,7 +34,9 @@ class TemplateDataset(BaseDataset):
         protocol intact.
     """
 
-    def __init__(self, root: Path, speaker: str = "default", download: bool = False) -> None:
+    def __init__(
+        self, root: Path, speaker: str = "default", download: bool = False
+    ) -> None:
         self.root = Path(root)
         self.speaker = speaker
         if download:

torchrir/datasets/utils.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 """Dataset-agnostic utilities."""
 
 import random
+from pathlib import Path
 from typing import Callable, List, Optional, Sequence, Tuple
 
 import torch
@@ -10,7 +11,9 @@ import torch
 from .base import BaseDataset, SentenceLike
 
 
-def choose_speakers(dataset: BaseDataset, num_sources: int, rng: random.Random) -> List[str]:
+def choose_speakers(
+    dataset: BaseDataset, num_sources: int, rng: random.Random
+) -> List[str]:
     """Select unique speakers for the requested number of sources.
 
     Example:
@@ -89,4 +92,23 @@ def load_dataset_sources(
         info.append((speaker, utterance_ids))
 
     stacked = torch.stack(signals, dim=0)
+    if fs is None:
+        raise RuntimeError("no audio loaded from dataset sources")
     return stacked, int(fs), info
+
+
+def load_wav_mono(path: Path) -> Tuple[torch.Tensor, int]:
+    """Load a wav/flac file and return mono audio and sample rate.
+
+    Example:
+        >>> audio, fs = load_wav_mono(Path("datasets/cmu_arctic/ARCTIC/.../wav/arctic_a0001.wav"))
+    """
+    import soundfile as sf
+
+    audio, sample_rate = sf.read(str(path), dtype="float32", always_2d=True)
+    audio_t = torch.from_numpy(audio)
+    if audio_t.shape[1] > 1:
+        audio_t = audio_t.mean(dim=1)
+    else:
+        audio_t = audio_t.squeeze(1)
+    return audio_t, sample_rate

torchrir/dynamic.py

@@ -44,7 +44,9 @@ class DynamicConvolver:
             if self.hop is None:
                 raise ValueError("hop must be provided for hop mode")
             return _convolve_dynamic_hop(signal, rirs, self.hop)
-        return _convolve_dynamic_trajectory(signal, rirs, timestamps=self.timestamps, fs=self.fs)
+        return _convolve_dynamic_trajectory(
+            signal, rirs, timestamps=self.timestamps, fs=self.fs
+        )
 
 
 def _convolve_dynamic_hop(signal: Tensor, rirs: Tensor, hop: int) -> Tensor:

torchrir/plotting.py

@@ -92,7 +92,9 @@ def plot_scene_dynamic(
     return ax
 
 
-def _setup_axes(ax: Any | None, room: Room | Sequence[float] | Tensor) -> tuple[Any, Any]:
+def _setup_axes(
+    ax: Any | None, room: Room | Sequence[float] | Tensor
+) -> tuple[Any, Any]:
     """Create 2D/3D axes based on room dimension."""
     import matplotlib.pyplot as plt
 
@@ -131,8 +133,9 @@ def _draw_room_2d(ax: Any, size: Tensor) -> None:
     """Draw a 2D rectangular room."""
     import matplotlib.patches as patches
 
-    rect = patches.Rectangle((0.0, 0.0), size[0].item(), size[1].item(),
-                             fill=False, edgecolor="black")
+    rect = patches.Rectangle(
+        (0.0, 0.0), size[0].item(), size[1].item(), fill=False, edgecolor="black"
+    )
     ax.add_patch(rect)
     ax.set_xlim(0, size[0].item())
     ax.set_ylim(0, size[1].item())
@@ -186,7 +189,9 @@ def _draw_room_3d(ax: Any, size: Tensor) -> None:
     ax.set_zlabel("z")
 
 
-def _extract_positions(entity: Source | MicrophoneArray | Tensor | Sequence, ax: Any | None) -> Tensor:
+def _extract_positions(
+    entity: Source | MicrophoneArray | Tensor | Sequence, ax: Any | None
+) -> Tensor:
     """Extract positions from Source/MicrophoneArray or raw tensor."""
     if isinstance(entity, (Source, MicrophoneArray)):
         pos = entity.positions
@@ -211,7 +216,9 @@ def _scatter_positions(
         return
     dim = positions.shape[1]
     if dim == 2:
-        ax.scatter(positions[:, 0], positions[:, 1], label=label, marker=marker, color=color)
+        ax.scatter(
+            positions[:, 0], positions[:, 1], label=label, marker=marker, color=color
+        )
     else:
         ax.scatter(
             positions[:, 0],
@@ -300,4 +307,4 @@ def _is_moving(traj: Tensor, positions: Tensor, *, tol: float = 1e-6) -> bool:
     if traj.numel() == 0:
         return False
     pos0 = positions.unsqueeze(0).expand_as(traj)
-    return torch.any(torch.linalg.norm(traj - pos0, dim=-1) > tol).item()
+    return bool(torch.any(torch.linalg.norm(traj - pos0, dim=-1) > tol).item())

torchrir/plotting_utils.py

@@ -127,7 +127,10 @@ def _positions_to_cpu(entity: torch.Tensor | object) -> torch.Tensor:
     return pos
 
 
-def _traj_steps(src_traj: Optional[torch.Tensor | Sequence], mic_traj: Optional[torch.Tensor | Sequence]) -> int:
+def _traj_steps(
+    src_traj: Optional[torch.Tensor | Sequence],
+    mic_traj: Optional[torch.Tensor | Sequence],
+) -> int:
     """Infer the number of trajectory steps."""
     if src_traj is not None:
         return int(_to_cpu(src_traj).shape[0])

torchrir/room.py

@@ -65,7 +65,7 @@ class Source:
     """Source container with positions and optional orientation.
 
     Example:
-        >>> sources = Source.positions([[1.0, 2.0, 1.5]])
+        >>> sources = Source.from_positions([[1.0, 2.0, 1.5]])
     """
 
     positions: Tensor
@@ -82,24 +82,6 @@ class Source:
         """Return a new Source with updated fields."""
         return replace(self, **kwargs)
 
-    @classmethod
-    def positions(
-        cls,
-        positions: Sequence[Sequence[float]] | Tensor,
-        *,
-        orientation: Optional[Sequence[float] | Tensor] = None,
-        device: Optional[torch.device | str] = None,
-        dtype: Optional[torch.dtype] = None,
-    ) -> "Source":
-        """Construct a Source from positions.
-
-        Example:
-            >>> sources = Source.positions([[1.0, 2.0, 1.5]])
-        """
-        return cls.from_positions(
-            positions, orientation=orientation, device=device, dtype=dtype
-        )
-
     @classmethod
     def from_positions(
         cls,
@@ -122,7 +104,7 @@ class MicrophoneArray:
     """Microphone array container.
 
     Example:
-        >>> mics = MicrophoneArray.positions([[2.0, 2.0, 1.5]])
+        >>> mics = MicrophoneArray.from_positions([[2.0, 2.0, 1.5]])
     """
 
     positions: Tensor
@@ -139,24 +121,6 @@ class MicrophoneArray:
         """Return a new MicrophoneArray with updated fields."""
         return replace(self, **kwargs)
 
-    @classmethod
-    def positions(
-        cls,
-        positions: Sequence[Sequence[float]] | Tensor,
-        *,
-        orientation: Optional[Sequence[float] | Tensor] = None,
-        device: Optional[torch.device | str] = None,
-        dtype: Optional[torch.dtype] = None,
-    ) -> "MicrophoneArray":
-        """Construct a MicrophoneArray from positions.
-
-        Example:
-            >>> mics = MicrophoneArray.positions([[2.0, 2.0, 1.5]])
-        """
-        return cls.from_positions(
-            positions, orientation=orientation, device=device, dtype=dtype
-        )
-
     @classmethod
     def from_positions(
         cls,

torchrir/scene_utils.py

@@ -32,7 +32,9 @@ def sample_positions(
     return torch.tensor(coords, dtype=torch.float32)
 
 
-def linear_trajectory(start: torch.Tensor, end: torch.Tensor, steps: int) -> torch.Tensor:
+def linear_trajectory(
+    start: torch.Tensor, end: torch.Tensor, steps: int
+) -> torch.Tensor:
     """Create a linear trajectory between start and end.
 
     Example:
@@ -58,7 +60,9 @@ def binaural_mic_positions(center: torch.Tensor, offset: float = 0.08) -> torch.
     return torch.stack([left, right], dim=0)
 
 
-def clamp_positions(positions: torch.Tensor, room_size: torch.Tensor, margin: float = 0.1) -> torch.Tensor:
+def clamp_positions(
+    positions: torch.Tensor, room_size: torch.Tensor, margin: float = 0.1
+) -> torch.Tensor:
     """Clamp positions to remain inside the room with a margin.
 
     Example:

torchrir/signal.py

@@ -117,9 +117,9 @@ def _convolve_dynamic_rir_trajectory(
     else:
         step_fs = n_samples / t_steps
         ts_dtype = torch.float32 if signal.device.type == "mps" else torch.float64
-        w_ini = (torch.arange(t_steps, device=signal.device, dtype=ts_dtype) * step_fs).to(
-            torch.long
-        )
+        w_ini = (
+            torch.arange(t_steps, device=signal.device, dtype=ts_dtype) * step_fs
+        ).to(torch.long)
 
     w_ini = torch.cat(
         [w_ini, torch.tensor([n_samples], device=signal.device, dtype=torch.long)]
@@ -132,14 +132,18 @@ def _convolve_dynamic_rir_trajectory(
         )
 
     max_len = int(w_len.max().item())
-    segments = torch.zeros((t_steps, n_src, max_len), dtype=signal.dtype, device=signal.device)
+    segments = torch.zeros(
+        (t_steps, n_src, max_len), dtype=signal.dtype, device=signal.device
+    )
     for t in range(t_steps):
         start = int(w_ini[t].item())
         end = int(w_ini[t + 1].item())
         if end > start:
             segments[t, :, : end - start] = signal[:, start:end]
 
-    out = torch.zeros((n_mic, n_samples + rir_len - 1), dtype=signal.dtype, device=signal.device)
+    out = torch.zeros(
+        (n_mic, n_samples + rir_len - 1), dtype=signal.dtype, device=signal.device
+    )
 
     for t in range(t_steps):
         seg_len = int(w_len[t].item())
@@ -166,7 +170,9 @@ def _convolve_dynamic_rir_trajectory_batched(
     """GPU-friendly batched trajectory convolution using FFT."""
     n_samples = signal.shape[1]
     t_steps, n_src, n_mic, rir_len = rirs.shape
-    out = torch.zeros((n_mic, n_samples + rir_len - 1), dtype=signal.dtype, device=signal.device)
+    out = torch.zeros(
+        (n_mic, n_samples + rir_len - 1), dtype=signal.dtype, device=signal.device
+    )
 
     for t0 in range(0, t_steps, chunk_size):
         t1 = min(t0 + chunk_size, t_steps)
@@ -174,7 +180,9 @@ def _convolve_dynamic_rir_trajectory_batched(
         max_len = int(lengths.max().item())
         if max_len == 0:
             continue
-        segments = torch.zeros((t1 - t0, n_src, max_len), dtype=signal.dtype, device=signal.device)
+        segments = torch.zeros(
+            (t1 - t0, n_src, max_len), dtype=signal.dtype, device=signal.device
+        )
         for idx, t in enumerate(range(t0, t1)):
             start = int(w_ini[t].item())
             end = int(w_ini[t + 1].item())
@@ -190,7 +198,9 @@ def _convolve_dynamic_rir_trajectory_batched(
             dtype=signal.dtype,
             device=signal.device,
         )
-        conv = torch.fft.irfft(seg_f[:, :, None, :] * rir_f, n=fft_len, dim=-1, out=conv_out)
+        conv = torch.fft.irfft(
+            seg_f[:, :, None, :] * rir_f, n=fft_len, dim=-1, out=conv_out
+        )
         conv = conv[..., :conv_len]
         conv_sum = conv.sum(dim=1)
 
@@ -199,7 +209,9 @@ def _convolve_dynamic_rir_trajectory_batched(
             if seg_len == 0:
                 continue
             start = int(w_ini[t].item())
-            out[:, start : start + seg_len + rir_len - 1] += conv_sum[idx, :, : seg_len + rir_len - 1]
+            out[:, start : start + seg_len + rir_len - 1] += conv_sum[
+                idx, :, : seg_len + rir_len - 1
+            ]
 
     return out.squeeze(0) if n_mic == 1 else out
 
@@ -221,7 +233,9 @@ def _ensure_static_rirs(rirs: Tensor) -> Tensor:
         return rirs.view(1, rirs.shape[0], rirs.shape[1])
     if rirs.ndim == 3:
         return rirs
-    raise ValueError("rirs must have shape (rir_len,), (n_mic, rir_len), or (n_src, n_mic, rir_len)")
+    raise ValueError(
+        "rirs must have shape (rir_len,), (n_mic, rir_len), or (n_src, n_mic, rir_len)"
+    )
 
 
 def _ensure_dynamic_rirs(rirs: Tensor, signal: Tensor) -> Tensor:

torchrir/simulators.py

@@ -18,7 +18,9 @@ from .scene import Scene
 class RIRSimulator(Protocol):
     """Strategy interface for RIR simulation backends."""
 
-    def simulate(self, scene: Scene, config: SimulationConfig | None = None) -> RIRResult:
+    def simulate(
+        self, scene: Scene, config: SimulationConfig | None = None
+    ) -> RIRResult:
         """Run a simulation and return the result."""
 
 
@@ -30,7 +32,9 @@ class ISMSimulator:
         >>> result = ISMSimulator().simulate(scene, config)
     """
 
-    def simulate(self, scene: Scene, config: SimulationConfig | None = None) -> RIRResult:
+    def simulate(
+        self, scene: Scene, config: SimulationConfig | None = None
+    ) -> RIRResult:
         scene.validate()
         cfg = config or default_config()
         if scene.is_dynamic():
@@ -71,7 +75,9 @@ class RayTracingSimulator:
         reuse Scene/SimulationConfig for inputs and keep output shape parity.
     """
 
-    def simulate(self, scene: Scene, config: SimulationConfig | None = None) -> RIRResult:
+    def simulate(
+        self, scene: Scene, config: SimulationConfig | None = None
+    ) -> RIRResult:
         raise NotImplementedError("RayTracingSimulator is not implemented yet")
 
 
@@ -86,5 +92,7 @@ class FDTDSimulator:
         RIRResult with the same metadata contract as ISM.
     """
 
-    def simulate(self, scene: Scene, config: SimulationConfig | None = None) -> RIRResult:
+    def simulate(
+        self, scene: Scene, config: SimulationConfig | None = None
+    ) -> RIRResult:
         raise NotImplementedError("FDTDSimulator is not implemented yet")

torchrir/utils.py

@@ -15,7 +15,7 @@ _DEF_SPEED_OF_SOUND = 343.0
 
 
 def as_tensor(
-    value: Tensor | Iterable[float] | float | int,
+    value: Tensor | Iterable[float] | Iterable[Iterable[float]] | float | int,
     *,
     device: Optional[torch.device | str] = None,
     dtype: Optional[torch.dtype] = None,

torchrir-0.2.0.dist-info/METADATA

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: torchrir
+Version: 0.2.0
+Summary: PyTorch-based room impulse response (RIR) simulation toolkit for static and dynamic scenes.
+Project-URL: Repository, https://github.com/taishi-n/torchrir
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: torch>=2.10.0
+Dynamic: license-file
+
+# TorchRIR
+
+PyTorch-based room impulse response (RIR) simulation toolkit focused on a clean, modern API with GPU support.
+This project has been substantially assisted by AI using Codex.
+
+## Installation
+```bash
+pip install torchrir
+```
+
+## Examples
+- `examples/static.py`: fixed sources/mics with binaural output.  
+  `uv run python examples/static.py --plot`
+- `examples/dynamic_src.py`: moving sources, fixed mics.  
+  `uv run python examples/dynamic_src.py --plot`
+- `examples/dynamic_mic.py`: fixed sources, moving mics.  
+  `uv run python examples/dynamic_mic.py --plot`
+- `examples/cli.py`: unified CLI for static/dynamic scenes, JSON/YAML configs.  
+  `uv run python examples/cli.py --mode static --plot`
+- `examples/cmu_arctic_dynamic_dataset.py`: small dynamic dataset generator (fixed room/mics, randomized source motion).  
+  `uv run python examples/cmu_arctic_dynamic_dataset.py --num-scenes 4 --num-sources 2`
+- `examples/benchmark_device.py`: CPU/GPU benchmark for RIR simulation.  
+  `uv run python examples/benchmark_device.py --dynamic`
+
+## Core API Overview
+- Geometry: `Room`, `Source`, `MicrophoneArray`
+- Static RIR: `simulate_rir`
+- Dynamic RIR: `simulate_dynamic_rir`
+- Dynamic convolution: `DynamicConvolver`
+- Metadata export: `build_metadata`, `save_metadata_json`
+
+```python
+from torchrir import DynamicConvolver, MicrophoneArray, Room, Source, simulate_rir
+
+room = Room.shoebox(size=[6.0, 4.0, 3.0], fs=16000, beta=[0.9] * 6)
+sources = Source.from_positions([[1.0, 2.0, 1.5]])
+mics = MicrophoneArray.from_positions([[2.0, 2.0, 1.5]])
+
+rir = simulate_rir(room=room, sources=sources, mics=mics, max_order=6, tmax=0.3)
+# For dynamic scenes, compute rirs with simulate_dynamic_rir and convolve:
+# y = DynamicConvolver(mode="trajectory").convolve(signal, rirs)
+```
+
+For detailed documentation, see the docs under `docs/` and Read the Docs.
+
+## Future Work
+- Ray tracing backend: implement `RayTracingSimulator` with frequency-dependent absorption/scattering.
+- CUDA-native acceleration: introduce dedicated CUDA kernels for large-scale RIR generation.
+- Dataset expansion: add additional dataset integrations beyond CMU ARCTIC (see `TemplateDataset`), including torchaudio datasets (e.g., LibriSpeech, VCTK, LibriTTS, SpeechCommands, CommonVoice, GTZAN, MUSDB-HQ).
+- Add regression tests comparing generated RIRs against gpuRIR outputs.
+
+## Related Libraries
+- [gpuRIR](https://github.com/DavidDiazGuerra/gpuRIR)
+- [Cross3D](https://github.com/DavidDiazGuerra/Cross3D)
+- [pyroomacoustics](https://github.com/LCAV/pyroomacoustics)
+- [das-generator](https://github.com/ehabets/das-generator)
+- [rir-generator](https://github.com/audiolabs/rir-generator)

torchrir-0.2.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+torchrir/__init__.py,sha256=MTlouAErvB7IyM4pcmhEN1U0KQsZBglWxUoHxnZDa5U,2615
+torchrir/animation.py,sha256=x3Y-BLz3J6DQNmoDIjbMEgGfng2yavJFLyQEmRCSpQU,6391
+torchrir/config.py,sha256=PsZdDIS3p4jepeNSHyd69aSD9QlOEdpG9v1SAXlZ_Fg,2295
+torchrir/core.py,sha256=Ug5thts1rXvCpdq9twVHz72oWygmk5J6gliloozHKL4,31704
+torchrir/directivity.py,sha256=v_t37YgeXF_IYzbnrk0TCs1npb_0yKR7zHiG8XV3V4w,1259
+torchrir/dynamic.py,sha256=01JHMxhORdcz93J-YaMIeSLo7k2tHrZke8llPHHXwZg,2153
+torchrir/logging_utils.py,sha256=s4jDSSDoHT0HKeplDUpGMsdeBij4eibLSpaaAPzkB68,2146
+torchrir/metadata.py,sha256=cwoXrr_yE2bQRUPnJe6p7POMPCWa9_oabCtp--WqBE8,6958
+torchrir/plotting.py,sha256=TM1LxPitZq5KXdNe1GfUCOnzFOzerGhWIFblzIz142A,8170
+torchrir/plotting_utils.py,sha256=Kg3TCLqEq_lxVQkYHI6vyz_6oG3Ic_Z8H9gZN-39QeI,5180
+torchrir/results.py,sha256=-HczEfr2u91BNb1xbrIGKCj0G3yzy7l_fmUMUeKbGRw,614
+torchrir/room.py,sha256=zFnEzw0Rr1NP9IUc3iNTInyoq6t3X-0yOyUtDnsLSPk,4325
+torchrir/scene.py,sha256=GuHuCspakAUOT81_ArTqaZbmBX0ApoJuCKTaZ21wGis,2435
+torchrir/scene_utils.py,sha256=2La5dtjxYdINX315VXRRJMJK9oaR2rY0xHmDLjZma8M,2140
+torchrir/signal.py,sha256=M0BpKDBqrfOmCHIJ_dvl-C3uKdFpXLDqtSIU115jsME,8383
+torchrir/simulators.py,sha256=NCl8Ptv2TGdBpNLwAb3nigT77On-BLIANtc2ivgKasw,3131
+torchrir/utils.py,sha256=2oE-JzAtkW5qdRds2Y5R5lbSyNZl_9piFXd6xOLzjxM,10680
+torchrir/datasets/__init__.py,sha256=NS4zQas9YdsuDv8KQtTKmIJmS6mxMRxQk2xGzglbgUw,853
+torchrir/datasets/base.py,sha256=LfdXO-NGCBtzaAqAeVxo8XuV5ieU6Vl91woqAHymsT8,1970
+torchrir/datasets/cmu_arctic.py,sha256=7IFv33RBBu044kTMO6nKUmziml2gjILUgnpL262rAU8,6593
+torchrir/datasets/collate.py,sha256=gZfaHog0gtb8Avg6qsDZ1m4yoKkYkcuwmty1RtLYhhI,2542
+torchrir/datasets/librispeech.py,sha256=XKlAm0Z0coipKuqR9Z8X8l9puXVYz7zb6yE3PCuMUrI,6019
+torchrir/datasets/template.py,sha256=pHAKj5E7Gehfk9pqdTsFQjiDV1OK3hSZJIbYutd-E4c,2090
+torchrir/datasets/utils.py,sha256=OCYd7Dbr2hsqBbiHE1LHPMYdqwe2YfDw0tpRMfND0Og,3790
+torchrir-0.2.0.dist-info/licenses/LICENSE,sha256=5vS_7WTsMEw_QQHEPQ_WCwovJXEgmxoEwcwOI-9VbXI,10766
+torchrir-0.2.0.dist-info/licenses/NOTICE,sha256=SRs_q-ZqoVF9_YuuedZOvVBk01jV7YQAeF8rRvlRg0s,118
+torchrir-0.2.0.dist-info/METADATA,sha256=0f5EhK2SWmP_RxZ2O8y7AIDP_dFaKaf9X_n0mt7045k,3077
+torchrir-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+torchrir-0.2.0.dist-info/top_level.txt,sha256=aIFwntowJjvm7rZk480HymC3ipDo1g-9hEbNY1wF-Oo,9
+torchrir-0.2.0.dist-info/RECORD,,