Datasets:
Download code/generation/native/render_static_v1_rirs.py from Heiheihaha17/MESH-Benchmark: direct link, hf CLI and curl.
- Browser
- Download file 16.1 kB
-
https://huggingface.co/datasets/Heiheihaha17/MESH-Benchmark/resolve/main/code/generation/native/render_static_v1_rirs.py
- Command line
-
hf download hf://datasets/Heiheihaha17/MESH-Benchmark/code/generation/native/render_static_v1_rirs.py
-
curl -L -o render_static_v1_rirs.py https://huggingface.co/datasets/Heiheihaha17/MESH-Benchmark/resolve/main/code/generation/native/render_static_v1_rirs.py
16.1 kB
| #!/usr/bin/env python3 | |
| """Render and validate a static V1 FOA RIR pilot with SoundSpaces 2.0.""" | |
| from __future__ import annotations | |
| import argparse | |
| import hashlib | |
| import itertools | |
| import json | |
| import math | |
| from pathlib import Path | |
| import numpy as np | |
| import quaternion # noqa: F401 - import before Habitat to avoid allocator issues | |
| from scipy.signal import butter, sosfilt | |
| import habitat_sim | |
| import habitat_sim.sim | |
| DEFAULT_RENDERER = { | |
| "sampleRate": 32000, | |
| "frequencyBands": 8, | |
| "directSHOrder": 3, | |
| "indirectSHOrder": 1, | |
| "threadCount": 8, | |
| "updateDt": 0.02, | |
| "irTime": 2.5, | |
| "unitScale": 1.0, | |
| "globalVolume": 0.25, | |
| "indirectRayCount": 15000, | |
| "indirectRayDepth": 200, | |
| "sourceRayCount": 1500, | |
| "sourceRayDepth": 10, | |
| "maxDiffractionOrder": 10, | |
| "direct": True, | |
| "indirect": True, | |
| "diffraction": True, | |
| "transmission": True, | |
| "meshSimplification": False, | |
| "temporalCoherence": False, | |
| "enableMaterials": True, | |
| "dumpWaveFiles": False, | |
| "writeIrToFile": False, | |
| } | |
| CALIBRATION_SOURCES = { | |
| # All six sources are exactly 1 m from the receiver so the linear fit is | |
| # not biased by distance attenuation. | |
| "world_pos_x": ([1.0, 1.35, 0.0], [1.0, 0.0, 0.0]), | |
| "world_neg_x": ([-1.0, 1.35, 0.0], [-1.0, 0.0, 0.0]), | |
| "world_pos_y": ([0.0, 2.35, 0.0], [0.0, 1.0, 0.0]), | |
| "world_neg_y": ([0.0, 0.35, 0.0], [0.0, -1.0, 0.0]), | |
| "world_pos_z": ([0.0, 1.35, 1.0], [0.0, 0.0, 1.0]), | |
| "world_neg_z": ([0.0, 1.35, -1.0], [0.0, 0.0, -1.0]), | |
| } | |
| def canonical_json_hash(value) -> str: | |
| blob = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8") | |
| return hashlib.sha256(blob).hexdigest() | |
| def file_hash(path: Path) -> str: | |
| digest = hashlib.sha256() | |
| with path.open("rb") as handle: | |
| for chunk in iter(lambda: handle.read(1024 * 1024), b""): | |
| digest.update(chunk) | |
| return digest.hexdigest() | |
| def set_if_present(obj, key, value) -> None: | |
| if not hasattr(obj, key): | |
| raise AttributeError(f"SoundSpaces acoustics config has no required field {key!r}") | |
| setattr(obj, key, value) | |
| def create_simulator(stage_config: Path, dataset_config: Path, material_json: Path, renderer: dict): | |
| backend = habitat_sim.SimulatorConfiguration() | |
| backend.scene_id = str(stage_config) | |
| backend.scene_dataset_config_file = str(dataset_config) | |
| backend.load_semantic_mesh = True | |
| backend.enable_physics = False | |
| if hasattr(backend, "random_seed"): | |
| backend.random_seed = 20260826 | |
| agent = habitat_sim.agent.AgentConfiguration() | |
| sim = habitat_sim.Simulator(habitat_sim.Configuration(backend, [agent])) | |
| if not sim.semantic_scene: | |
| sim.close() | |
| raise RuntimeError("Semantic scene was not loaded; refusing to fall back to default acoustic material") | |
| spec = habitat_sim.AudioSensorSpec() | |
| spec.uuid = "audio_sensor" | |
| spec.channelLayout.channelType = habitat_sim.sensor.RLRAudioPropagationChannelLayoutType.Ambisonics | |
| spec.channelLayout.channelCount = 4 | |
| spec.position = [0.0, 0.0, 0.0] | |
| for key, value in renderer.items(): | |
| set_if_present(spec.acousticsConfig, key, value) | |
| sim.add_sensor(spec) | |
| audio_sensor = sim.get_agent(0)._sensors["audio_sensor"] | |
| audio_sensor.setAudioMaterialsJSON(str(material_json)) | |
| return sim | |
| def set_listener_identity(sim, position) -> None: | |
| agent = sim.get_agent(0) | |
| state = agent.get_state() | |
| state.position = np.asarray(position, dtype=np.float32) | |
| state.rotation = np.quaternion(1.0, 0.0, 0.0, 0.0) | |
| state.sensor_states = {} | |
| agent.set_state(state, True) | |
| def render(sim, source_position) -> np.ndarray: | |
| sensor = sim.get_agent(0)._sensors["audio_sensor"] | |
| sensor.setAudioSourceTransform(np.asarray(source_position, dtype=np.float32)) | |
| observation = np.asarray(sim.get_sensor_observations()["audio_sensor"], dtype=np.float32) | |
| if observation.ndim != 2: | |
| raise RuntimeError(f"Unexpected RIR shape: {observation.shape}") | |
| rir = observation if observation.shape[0] == 4 else observation.T | |
| if rir.shape[0] != 4 or not np.isfinite(rir).all() or not np.any(rir): | |
| raise RuntimeError(f"Invalid FOA RIR: shape={rir.shape}") | |
| return np.ascontiguousarray(rir, dtype=np.float32) | |
| def direct_sample_vector(rir: np.ndarray) -> tuple[int, np.ndarray]: | |
| energy = np.sum(np.square(rir.astype(np.float64)), axis=0) | |
| peak = int(np.argmax(energy)) | |
| lo, hi = max(0, peak - 1), min(rir.shape[1], peak + 2) | |
| local = rir[:, lo:hi] | |
| index = int(np.argmax(np.sum(np.square(local.astype(np.float64)), axis=0))) | |
| return lo + index, local[:, index].astype(np.float64) | |
| def infer_native_foa(calibration_rirs: dict[str, np.ndarray]) -> dict: | |
| directions, amplitudes, peaks = [], [], {} | |
| for name, (_, direction) in CALIBRATION_SOURCES.items(): | |
| peak, vector = direct_sample_vector(calibration_rirs[name]) | |
| directions.append(direction) | |
| amplitudes.append(vector) | |
| peaks[name] = peak | |
| design = np.column_stack([np.ones(len(directions)), np.asarray(directions, dtype=np.float64)]) | |
| amplitude_matrix = np.asarray(amplitudes, dtype=np.float64) | |
| coefficients = np.linalg.lstsq(design, amplitude_matrix, rcond=None)[0].T | |
| scores = [] | |
| for channel, row in enumerate(coefficients): | |
| intercept = abs(row[0]) | |
| directional = float(np.linalg.norm(row[1:])) | |
| scores.append(intercept / (directional + 1e-12)) | |
| w_channel = int(np.argmax(scores)) | |
| direction_channels = [channel for channel in range(4) if channel != w_channel] | |
| best = None | |
| for permutation in itertools.permutations(range(3)): | |
| score = sum(abs(coefficients[channel, 1 + axis]) for channel, axis in zip(direction_channels, permutation)) | |
| if best is None or score > best[0]: | |
| best = (score, permutation) | |
| assert best is not None | |
| native_by_world_axis = {} | |
| axis_names = ("world_x", "world_y", "world_z") | |
| for channel, axis in zip(direction_channels, best[1]): | |
| coefficient = coefficients[channel, 1 + axis] | |
| native_by_world_axis[axis_names[axis]] = { | |
| "channel": channel, | |
| "polarity": 1 if coefficient >= 0 else -1, | |
| "fit_coefficient": float(coefficient), | |
| } | |
| return { | |
| "method": "six_equal_distance_axis_sources_linear_fit", | |
| "native_normalization": "N3D", | |
| "w_channel": w_channel, | |
| "w_polarity": 1 if coefficients[w_channel, 0] >= 0 else -1, | |
| "world_axis_mapping": native_by_world_axis, | |
| "fit_coefficients_intercept_xyz": coefficients.tolist(), | |
| "direct_peak_samples": peaks, | |
| } | |
| def native_to_ambix_robot(rir: np.ndarray, mapping: dict, yaw_deg: float) -> np.ndarray: | |
| w = mapping["w_polarity"] * rir[mapping["w_channel"]] | |
| world = {} | |
| for axis in ("world_x", "world_y", "world_z"): | |
| item = mapping["world_axis_mapping"][axis] | |
| world[axis] = item["polarity"] * rir[item["channel"]] / math.sqrt(3.0) | |
| yaw = math.radians(yaw_deg) | |
| cos_yaw, sin_yaw = math.cos(yaw), math.sin(yaw) | |
| right = cos_yaw * world["world_x"] - sin_yaw * world["world_z"] | |
| up = world["world_y"] | |
| front = -sin_yaw * world["world_x"] - cos_yaw * world["world_z"] | |
| return np.stack([w, -right, up, front]).astype(np.float32) | |
| def decay_fit(signal: np.ndarray, sample_rate: int, upper_db: float, lower_db: float): | |
| energy = np.square(signal.astype(np.float64)) | |
| peak = int(np.argmax(energy)) | |
| decay = np.cumsum(energy[peak:][::-1])[::-1] | |
| if not len(decay) or decay[0] <= 0: | |
| return None | |
| db = 10.0 * np.log10(np.maximum(decay / decay[0], 1e-14)) | |
| mask = (db <= upper_db) & (db >= lower_db) | |
| if np.count_nonzero(mask) < 20: | |
| return None | |
| times = np.arange(len(db), dtype=np.float64) / sample_rate | |
| slope, intercept = np.polyfit(times[mask], db[mask], 1) | |
| if slope >= 0: | |
| return None | |
| return {"rt60_s": float(-60.0 / slope), "slope_db_per_s": float(slope), | |
| "fit_intercept_db": float(intercept), "fit_points": int(np.count_nonzero(mask))} | |
| def acoustic_metrics(rir_ambix: np.ndarray, sample_rate: int) -> dict: | |
| w = rir_ambix[0].astype(np.float64) | |
| peak = int(np.argmax(np.square(w))) | |
| direct_end = min(len(w), peak + max(1, round(0.003 * sample_rate))) | |
| c50_end = min(len(w), peak + round(0.050 * sample_rate)) | |
| eps = 1e-18 | |
| direct = float(np.sum(np.square(w[peak:direct_end]))) + eps | |
| reverberant = float(np.sum(np.square(w[direct_end:]))) + eps | |
| early = float(np.sum(np.square(w[peak:c50_end]))) + eps | |
| late = float(np.sum(np.square(w[c50_end:]))) + eps | |
| broadband = { | |
| "first_peak_s": float(peak / sample_rate), | |
| "drr_db": float(10 * math.log10(direct / reverberant)), | |
| "c50_db": float(10 * math.log10(early / late)), | |
| "edt_s": None, | |
| "t20_rt60_s": None, | |
| "t30_rt60_s": None, | |
| } | |
| edt = decay_fit(w, sample_rate, 0.0, -10.0) | |
| t20 = decay_fit(w, sample_rate, -5.0, -25.0) | |
| t30 = decay_fit(w, sample_rate, -5.0, -35.0) | |
| broadband["edt_s"] = None if edt is None else edt["rt60_s"] | |
| broadband["t20_rt60_s"] = None if t20 is None else t20["rt60_s"] | |
| broadband["t30_rt60_s"] = None if t30 is None else t30["rt60_s"] | |
| bands = {} | |
| nyquist = sample_rate / 2.0 | |
| for centre in (500, 1000, 2000): | |
| low, high = centre / math.sqrt(2.0), centre * math.sqrt(2.0) | |
| sos = butter(4, [low / nyquist, high / nyquist], btype="bandpass", output="sos") | |
| filtered = sosfilt(sos, w) | |
| fit = decay_fit(filtered, sample_rate, -5.0, -25.0) | |
| bands[str(centre)] = None if fit is None else fit["rt60_s"] | |
| valid_bands = [value for value in bands.values() if value is not None] | |
| return {"broadband": broadband, "t20_rt60_octave_s": bands, | |
| "acceptance_rt60_median_s": None if not valid_bands else float(np.median(valid_bands))} | |
| def main() -> None: | |
| root = Path(__file__).resolve().parents[1] | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("--scenarios", type=Path, default=root.parent / "simulation_scenarios" / "pilot_scenarios.json") | |
| parser.add_argument("--scenario-id", default="EASE-V1-01") | |
| parser.add_argument("--scene-dir", type=Path, default=root / "scene" / "static_v1" / "exhibition_hall_base") | |
| parser.add_argument("--materials", type=Path, default=root / "materials" / "static_v1_absorptive.json") | |
| parser.add_argument("--output-dir", type=Path, default=root / "assets" / "static_v1" / "rir" / "EASE-V1-01") | |
| parser.add_argument("--target-rt60-s", type=float, nargs=2, | |
| metavar=("MIN", "MAX"), help="override the scenario-wide acceptance interval") | |
| parser.add_argument("--rays", type=int, default=15000) | |
| parser.add_argument("--threads", type=int, default=8) | |
| args = parser.parse_args() | |
| scenario_doc = json.loads(args.scenarios.read_text(encoding="utf-8")) | |
| scenario = next(item for item in scenario_doc["scenarios"] if item["id"] == args.scenario_id) | |
| renderer = dict(DEFAULT_RENDERER) | |
| renderer["sampleRate"] = int(scenario_doc["audio_contract"]["sample_rate_hz"]) | |
| renderer["indirectRayCount"] = args.rays | |
| renderer["sourceRayCount"] = max(500, args.rays // 10) | |
| renderer["threadCount"] = args.threads | |
| layout_path = (args.scene_dir / "layout.json").resolve() | |
| if not layout_path.is_file(): | |
| raise FileNotFoundError(layout_path) | |
| layout = json.loads(layout_path.read_text(encoding="utf-8")) | |
| stage_config = Path(layout["stage_config"]).resolve() | |
| dataset_config = Path(layout["scene_dataset_config"]).resolve() | |
| semantic_glb = Path(layout["semantic_asset"]).resolve() | |
| materials = args.materials.resolve() | |
| for required in (stage_config, dataset_config, semantic_glb, materials, args.scenarios): | |
| if not required.is_file(): | |
| raise FileNotFoundError(required) | |
| output_dir = args.output_dir.resolve() | |
| output_dir.mkdir(parents=True, exist_ok=True) | |
| listener_position = scenario["scene_sampling"]["receiver_position_candidates"][0] | |
| yaw_values = scenario["scene_sampling"]["receiver_yaw_deg_values"] | |
| listener_yaw = float(min(yaw_values, key=lambda value: abs(float(value)))) | |
| sim = create_simulator(stage_config, dataset_config, materials, renderer) | |
| raw_rirs = {} | |
| try: | |
| set_listener_identity(sim, listener_position) | |
| for name, (position, _) in CALIBRATION_SOURCES.items(): | |
| print(f"render calibration {name} @ {position}", flush=True) | |
| raw_rirs[name] = render(sim, position) | |
| mapping = infer_native_foa(raw_rirs) | |
| print("inferred native FOA mapping: " + json.dumps(mapping, ensure_ascii=False), flush=True) | |
| records = [] | |
| for source in scenario["sources"]: | |
| print(f"render {scenario['id']} source {source['id']} @ {source['position']}", flush=True) | |
| raw = render(sim, source["position"]) | |
| canonical = native_to_ambix_robot(raw, mapping, listener_yaw) | |
| raw_path = output_dir / f"{source['id']}.native_n3d.npy" | |
| canonical_path = output_dir / f"{source['id']}.ambix_sn3d.npy" | |
| np.save(raw_path, raw, allow_pickle=False) | |
| np.save(canonical_path, canonical, allow_pickle=False) | |
| metrics = acoustic_metrics(canonical, renderer["sampleRate"]) | |
| records.append({ | |
| "source_id": source["id"], "source_class": source["source_class"], | |
| "source_position_xyz_m": source["position"], | |
| "nominal_azimuth_deg": source["nominal_azimuth_deg"], | |
| "native_rir": raw_path.name, "canonical_rir": canonical_path.name, | |
| "shape": list(canonical.shape), "metrics": metrics, | |
| }) | |
| finally: | |
| sim.close() | |
| target_rt60 = args.target_rt60_s or scenario["acoustic_profile"]["target_rt60_s_range"] | |
| medians = [item["metrics"]["acceptance_rt60_median_s"] for item in records] | |
| acceptance = all(value is not None and target_rt60[0] <= value <= target_rt60[1] for value in medians) | |
| fingerprint_payload = { | |
| "scenario": scenario, "renderer": renderer, | |
| "stage_sha256": file_hash(stage_config), "semantic_glb_sha256": file_hash(semantic_glb), | |
| "materials_sha256": file_hash(materials), "listener_position": listener_position, "listener_yaw_deg": listener_yaw, | |
| } | |
| manifest = { | |
| "renderer": "SoundSpaces 2.0 / Habitat-Sim AudioSensor", | |
| "scenario_id": scenario["id"], "sample_rate_hz": renderer["sampleRate"], | |
| "receiver_position_xyz_m": listener_position, | |
| "receiver_yaw_deg": listener_yaw, | |
| "scene": { | |
| "geometry_id": layout["geometry_id"], | |
| "room_size_variant": layout.get("room_size_variant", "base"), | |
| "room_size_m": layout["room_size_m"], | |
| "layout_template": layout.get("layout_template", "open_center"), | |
| "center_occluder_type": layout.get("center_occluder_type", "none"), | |
| "layout_sha256": file_hash(layout_path), | |
| }, | |
| "materials_file": str(materials), | |
| "materials_sha256": file_hash(materials), | |
| "output_format": "AmbiX ACN SN3D [W,Y,Z,X], robot-relative", | |
| "native_format": "SoundSpaces four-channel Ambisonics N3D; mapping inferred, not assumed", | |
| "materials_enabled": True, "semantic_mesh_required_and_loaded": True, | |
| "renderer_config": renderer, "native_foa_calibration": mapping, | |
| "target_rt60_s_range": target_rt60, "rt60_acceptance_passed": acceptance, | |
| "acoustic_config_sha256": canonical_json_hash(fingerprint_payload), "rirs": records, | |
| } | |
| manifest_path = output_dir / "rir_manifest.json" | |
| manifest_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") | |
| print(f"wrote {manifest_path}", flush=True) | |
| print(f"RT60 acceptance: {acceptance}; medians={medians}; target={target_rt60}", flush=True) | |
| if not acceptance: | |
| raise SystemExit(2) | |
| if __name__ == "__main__": | |
| main() | |