MESH-Benchmark / code /generation /native /render_static_v1_rirs.py
Heiheihaha17's picture
Add files using upload-large-folder tool
85407a7 verified
Raw History Blame Contribute Delete
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()