File size: 3,125 Bytes
9ade843
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
"""SRP-PHAT direction-of-arrival on the Aria 7-mic array (VRS stream 231-1), expressed in the CPF frame.
az_deg: + = wearer's left, 0 = straight ahead, ±180 = behind (CPF: x left, y up, z forward)."""
import numpy as np
from projectaria_tools.core import data_provider
from projectaria_tools.core.sensor_data import TimeDomain

C = 343.0; FS = 48000; NFFT = 1024

class ArrayDOA:
    def __init__(self, vrs):
        self.p = data_provider.create_vrs_data_provider(vrs)
        self.sid = self.p.get_stream_id_from_label('mic')
        cal = self.p.get_device_calibration()
        T_cpf_dev = cal.get_transform_device_cpf().inverse()
        self.mics = np.array([(T_cpf_dev @ cal.get_transform_device_sensor(l, True)).translation()[0]
                              for l in cal.get_microphone_labels()])  # 7x3 in CPF
        az = np.radians(np.arange(-180, 180, 3)); el = np.radians(np.arange(-60, 61, 15))
        A, E = np.meshgrid(az, el)
        self.grid_az, self.grid_el = np.degrees(A).ravel(), np.degrees(E).ravel()
        self.dirs = np.stack([np.cos(E) * np.sin(A), np.sin(E), np.cos(E) * np.cos(A)], -1).reshape(-1, 3)
        self.pairs = [(i, j) for i in range(7) for j in range(i + 1, 7)]
        freqs = np.fft.rfftfreq(NFFT, 1 / FS); self.band = (freqs > 300) & (freqs < 6000); self.f = freqs[self.band]
        # tdoa (s) for each dir and pair: arrival at i earlier than j by (m_i - m_j)·d / c
        dm = np.array([self.mics[i] - self.mics[j] for i, j in self.pairs])
        tau = self.dirs @ dm.T / C  # D x P
        self.steer = np.exp(-2j * np.pi * tau[:, :, None] * self.f[None, None, :])  # D x P x F

    def audio(self, t0, t1):
        i0 = self.p.get_index_by_time_ns(self.sid, int(t0 * 1e9), TimeDomain.DEVICE_TIME)
        out = []
        for i in range(i0, self.p.get_num_data(self.sid)):
            d, rec = self.p.get_audio_data_by_index(self.sid, i)
            ts = rec.capture_timestamps_ns
            if not ts: continue
            if ts[0] / 1e9 > t1: break
            x = np.array(d.data, dtype=np.float64).reshape(-1, 7)
            tt = np.array(ts) / 1e9; m = (tt >= t0) & (tt <= t1)
            out.append(x[m])
        return np.concatenate(out) if out else np.zeros((0, 7))

    def estimate(self, t0, t1):
        x = self.audio(t0, t1)
        if len(x) < NFFT * 2: return None
        x = x - x.mean(0)
        hop = NFFT // 2; win = np.hanning(NFFT)
        frames = np.stack([x[s:s + NFFT] * win[:, None] for s in range(0, len(x) - NFFT, hop)])
        X = np.fft.rfft(frames, axis=1)[:, self.band, :]  # T x F x 7
        energy = (np.abs(X) ** 2).sum((1, 2)); keep = energy >= np.percentile(energy, 50)
        X = X[keep]
        R = np.stack([(X[:, :, i] * np.conj(X[:, :, j])) for i, j in self.pairs], 1)  # T x P x F
        R = R / (np.abs(R) + 1e-12)
        Rm = R.mean(0)  # P x F
        srp = np.real((Rm[None] * self.steer).sum((1, 2)))
        k = int(np.argmax(srp))
        return {'az_deg': float(self.grid_az[k]), 'el_deg': float(self.grid_el[k]),
                'peak_ratio': float(srp[k] / (np.median(srp) + 1e-9)), 'dur': float((t1 - t0))}