feat: add standard full-band activity detectors
This commit is contained in:
@@ -0,0 +1,372 @@
|
||||
import {
|
||||
computeDixonSpectralFlux,
|
||||
pickCausalSpectralFluxPeaks,
|
||||
} from "/packages/acoustics-core/spectral-flux.js";
|
||||
|
||||
function assertNear(actual, expected, tolerance, label) {
|
||||
assert(
|
||||
Math.abs(actual - expected) <= tolerance,
|
||||
`${label}: expected ${expected} +/- ${tolerance}, received ${actual}`,
|
||||
);
|
||||
}
|
||||
|
||||
function assertArrayNear(actual, expected, tolerance, label) {
|
||||
assertEqual(actual.length, expected.length, `${label} length`);
|
||||
for (let index = 0; index < expected.length; index += 1) {
|
||||
assertNear(actual[index], expected[index], tolerance, `${label}[${index}]`);
|
||||
}
|
||||
}
|
||||
|
||||
function assertArrayExact(actual, expected, label) {
|
||||
assertEqual(actual.length, expected.length, `${label} length`);
|
||||
for (let index = 0; index < expected.length; index += 1) {
|
||||
assertEqual(actual[index], expected[index], `${label}[${index}]`);
|
||||
}
|
||||
}
|
||||
|
||||
function assertThrows(callback, ErrorType, expectedText, label) {
|
||||
let caught = null;
|
||||
try {
|
||||
callback();
|
||||
} catch (error) {
|
||||
caught = error;
|
||||
}
|
||||
assert(caught instanceof ErrorType, `${label}: expected ${ErrorType.name}`);
|
||||
assert(
|
||||
caught.message.includes(expectedText),
|
||||
`${label}: expected message containing "${expectedText}", received "${caught.message}"`,
|
||||
);
|
||||
}
|
||||
|
||||
function fluxConfiguration(samples, overrides = {}) {
|
||||
return {
|
||||
samples,
|
||||
sampleRate: 4,
|
||||
fftSize: 4,
|
||||
hopSize: 4,
|
||||
channelId: "adc-channel-0",
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
test("Dixon flux는 Hamming linear magnitude의 양의 차이를 full DFT에서 그대로 합산한다", () => {
|
||||
const result = computeDixonSpectralFlux(fluxConfiguration(
|
||||
Float64Array.of(0, 0, 0, 0, 1, 1, 1, 1),
|
||||
{ maximumOutputBytes: 128 },
|
||||
));
|
||||
const sideMagnitude = Math.hypot(-0.69, -0.69);
|
||||
const expectedSecondFrame = [1.7, sideMagnitude, 0, sideMagnitude];
|
||||
|
||||
assertEqual(result.frameCount, 2, "frame count");
|
||||
assertEqual(result.binCount, 4, "full DFT bin count");
|
||||
assert(result.rawOdf instanceof Float64Array, "raw ODF type");
|
||||
assert(result.positiveDifferences instanceof Float64Array, "raw per-bin type");
|
||||
assertArrayExact(result.positiveDifferences.subarray(0, 4), [0, 0, 0, 0], "first frame");
|
||||
assertArrayNear(
|
||||
result.positiveDifferences.subarray(4, 8),
|
||||
expectedSecondFrame,
|
||||
1e-12,
|
||||
"second-frame positive differences",
|
||||
);
|
||||
assertNear(
|
||||
result.rawOdf[1],
|
||||
expectedSecondFrame.reduce((sum, value) => sum + value, 0),
|
||||
1e-12,
|
||||
"raw L1 ODF",
|
||||
);
|
||||
assertArrayExact(result.frameStartSamples, [0, 4], "frame starts");
|
||||
assertArrayExact(result.frameCenterSamples, [1.5, 5.5], "frame centers");
|
||||
assertArrayExact(result.frameAvailableAfterSamples, [4, 8], "causal availability");
|
||||
assertEqual(result.latency.firstDifferenceAvailableAfterSamples, 8, "first difference latency");
|
||||
assertEqual(result.provenance.input.channelId, "adc-channel-0", "explicit channel provenance");
|
||||
assertEqual(result.provenance.input.microphoneFusion, "none", "no microphone fusion");
|
||||
assertEqual(result.provenance.globalNormalization, "none", "no global normalization");
|
||||
assertEqual(result.provenance.magnitudeScale, "linear", "linear magnitude");
|
||||
assertEqual(
|
||||
result.provenance.stft.spectrumBins,
|
||||
"full-dft-bin-order-including-the-real-signal-negative-frequency-mirror",
|
||||
"full DFT aggregation disclosure",
|
||||
);
|
||||
assertEqual(result.workload.positiveDifferenceBytes, 64, "raw bin bytes");
|
||||
assertEqual(result.workload.outputBytes, 128, "total returned typed-array bytes");
|
||||
assertEqual(result.workload.maximumOutputBytes, 128, "caller output limit");
|
||||
});
|
||||
|
||||
test("Dixon flux는 silence와 incomplete tail을 패딩 없이 처리한다", () => {
|
||||
const samples = new Float64Array(9);
|
||||
samples[8] = 1_000_000;
|
||||
const result = computeDixonSpectralFlux(fluxConfiguration(samples));
|
||||
|
||||
assertEqual(result.frameCount, 2, "only two complete frames");
|
||||
assertArrayExact(result.rawOdf, [0, 0], "silent raw ODF");
|
||||
assertArrayExact(
|
||||
result.positiveDifferences,
|
||||
new Float64Array(8),
|
||||
"silent per-bin differences",
|
||||
);
|
||||
assertEqual(result.latency.completeFramesOnly, true, "complete frame policy");
|
||||
assertEqual(
|
||||
result.provenance.stft.framePolicy,
|
||||
"complete-only-no-padding",
|
||||
"no padding provenance",
|
||||
);
|
||||
|
||||
const tooShort = computeDixonSpectralFlux(fluxConfiguration(
|
||||
Float64Array.of(1, 2, 3),
|
||||
{ maximumOutputBytes: 1 },
|
||||
));
|
||||
assertEqual(tooShort.frameCount, 0, "short input has no frame");
|
||||
assertEqual(tooShort.workload.outputBytes, 0, "short input allocates no output data");
|
||||
assertEqual(tooShort.workload.workspaceBytes, 0, "short input allocates no FFT workspace");
|
||||
});
|
||||
|
||||
test("정상상태 tone은 최초 spectral rise 뒤 raw flux가 0에 가까워지는 한계를 보존한다", () => {
|
||||
const tone = Float64Array.from(
|
||||
{ length: 8 },
|
||||
(_, index) => Math.cos((2 * Math.PI * index) / 8),
|
||||
);
|
||||
const samples = new Float64Array(24);
|
||||
samples.set(tone, 8);
|
||||
samples.set(tone, 16);
|
||||
const result = computeDixonSpectralFlux({
|
||||
samples,
|
||||
sampleRate: 8,
|
||||
fftSize: 8,
|
||||
hopSize: 8,
|
||||
channelId: "tone-channel",
|
||||
});
|
||||
|
||||
assertEqual(result.frameCount, 3, "three complete frames");
|
||||
assertEqual(result.rawOdf[0], 0, "no predecessor for first frame");
|
||||
assert(result.rawOdf[1] > 0, "tone rise is nonzero");
|
||||
assertNear(result.rawOdf[2], 0, 1e-12, "unchanged tone flux");
|
||||
assertArrayNear(
|
||||
result.positiveDifferences.subarray(16, 24),
|
||||
new Float64Array(8),
|
||||
1e-12,
|
||||
"unchanged tone per-bin differences",
|
||||
);
|
||||
assertEqual(
|
||||
result.measurementSemantics.sustainedActivityMeasure,
|
||||
false,
|
||||
"not a sustained activity measure",
|
||||
);
|
||||
assert(
|
||||
result.limitations.steadySound.includes("steady spectrum produces zero flux"),
|
||||
"steady-sound limitation is structural metadata",
|
||||
);
|
||||
});
|
||||
|
||||
test("Boeck causal peak picker는 과거 max/mean, delta와 strict refractory만 사용한다", () => {
|
||||
const source = Float64Array.of(0, 1, 0, 10, 0);
|
||||
const configuration = {
|
||||
delta: 0.4,
|
||||
preMaxFrames: 1,
|
||||
preMeanFrames: 2,
|
||||
refractoryFrames: 1,
|
||||
};
|
||||
const result = pickCausalSpectralFluxPeaks(source, configuration);
|
||||
|
||||
assertArrayExact(result.rawOdf, [0, 1, 0, 10, 0], "preserved raw ODF");
|
||||
assertArrayNear(
|
||||
result.adaptiveThresholds,
|
||||
[0.4, 0.9, 1 / 3 + 0.4, 11 / 3 + 0.4, 10 / 3 + 0.4],
|
||||
1e-12,
|
||||
"causal thresholds",
|
||||
);
|
||||
assertArrayExact(result.peakFrameIndices, [1, 3], "causal peaks");
|
||||
assertArrayExact(result.peakMask, [0, 1, 0, 1, 0], "peak mask");
|
||||
assertEqual(result.configuration.postMaxFrames, 0, "no future maximum frames");
|
||||
assertEqual(result.configuration.postMeanFrames, 0, "no future mean frames");
|
||||
assertEqual(result.latency.futureContextFrames, 0, "no future context");
|
||||
assertEqual(result.provenance.globalNormalization, "none", "no peak-picker normalization");
|
||||
assertEqual(
|
||||
result.measurementSemantics.kind,
|
||||
"thresholded-onset-events-from-raw-novelty",
|
||||
"event semantics",
|
||||
);
|
||||
|
||||
const prefix = pickCausalSpectralFluxPeaks(Float64Array.of(0, 1), configuration);
|
||||
assertArrayExact(prefix.peakFrameIndices, [1], "prefix peak");
|
||||
assertEqual(prefix.adaptiveThresholds[1], result.adaptiveThresholds[1], "future invariance");
|
||||
|
||||
const refractory = pickCausalSpectralFluxPeaks(
|
||||
Float64Array.of(0, 1, 0, 2),
|
||||
{
|
||||
delta: 0.4,
|
||||
preMaxFrames: 1,
|
||||
preMeanFrames: 1,
|
||||
refractoryFrames: 2,
|
||||
},
|
||||
);
|
||||
assertArrayExact(refractory.peakFrameIndices, [1], "strict refractory boundary");
|
||||
|
||||
source[1] = 99;
|
||||
assertEqual(result.rawOdf[1], 1, "returned raw ODF is a preserved copy");
|
||||
});
|
||||
|
||||
test("spectral flux와 causal picker는 non-finite 및 음수 novelty를 거부한다", () => {
|
||||
assertThrows(
|
||||
() => computeDixonSpectralFlux(fluxConfiguration(Float64Array.of(0, Number.NaN, 0, 0))),
|
||||
TypeError,
|
||||
"samples[1] must be finite",
|
||||
"NaN sample",
|
||||
);
|
||||
assertThrows(
|
||||
() => computeDixonSpectralFlux(fluxConfiguration(
|
||||
Float64Array.of(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE),
|
||||
)),
|
||||
RangeError,
|
||||
"STFT magnitude became non-finite",
|
||||
"overflowing transform",
|
||||
);
|
||||
assertThrows(
|
||||
() => pickCausalSpectralFluxPeaks(
|
||||
Float64Array.of(0, Number.POSITIVE_INFINITY),
|
||||
{ delta: 1, preMaxFrames: 1, preMeanFrames: 1, refractoryFrames: 1 },
|
||||
),
|
||||
TypeError,
|
||||
"samples[1] must be finite",
|
||||
"infinite ODF",
|
||||
);
|
||||
assertThrows(
|
||||
() => pickCausalSpectralFluxPeaks(
|
||||
Float64Array.of(0, -1),
|
||||
{ delta: 1, preMaxFrames: 1, preMeanFrames: 1, refractoryFrames: 1 },
|
||||
),
|
||||
RangeError,
|
||||
"rawOdfInput[1] must be non-negative",
|
||||
"negative ODF",
|
||||
);
|
||||
assertThrows(
|
||||
() => pickCausalSpectralFluxPeaks(
|
||||
Float64Array.of(0, 1),
|
||||
{ delta: Number.NaN, preMaxFrames: 1, preMeanFrames: 1, refractoryFrames: 1 },
|
||||
),
|
||||
RangeError,
|
||||
"delta must be finite",
|
||||
"non-finite delta",
|
||||
);
|
||||
});
|
||||
|
||||
test("spectral flux 설정은 single channel, FFT, provenance와 출력 상한을 명시적으로 검증한다", () => {
|
||||
assertThrows(
|
||||
() => computeDixonSpectralFlux({
|
||||
samples: Float64Array.of(0, 0, 0, 0),
|
||||
sampleRate: 4,
|
||||
fftSize: 4,
|
||||
hopSize: 4,
|
||||
}),
|
||||
TypeError,
|
||||
"channelId must be provided explicitly",
|
||||
"missing channel id",
|
||||
);
|
||||
assertThrows(
|
||||
() => computeDixonSpectralFlux(fluxConfiguration(Float64Array.of(0, 0, 0, 0), {
|
||||
channelId: "",
|
||||
})),
|
||||
TypeError,
|
||||
"channelId must be a non-empty string",
|
||||
"empty channel id",
|
||||
);
|
||||
assertThrows(
|
||||
() => computeDixonSpectralFlux(fluxConfiguration([[0], [0], [0], [0]])),
|
||||
TypeError,
|
||||
"samples[0] must be finite",
|
||||
"channel collection",
|
||||
);
|
||||
assertThrows(
|
||||
() => computeDixonSpectralFlux(fluxConfiguration(new Float64Array(8), { fftSize: 3 })),
|
||||
RangeError,
|
||||
"power-of-two integer",
|
||||
"non-radix FFT",
|
||||
);
|
||||
assertThrows(
|
||||
() => computeDixonSpectralFlux(fluxConfiguration(new Float64Array(8), {
|
||||
fftSize: 2 ** 32,
|
||||
})),
|
||||
RangeError,
|
||||
"through 536870912",
|
||||
"FFT exceeds radix implementation limit",
|
||||
);
|
||||
assertThrows(
|
||||
() => computeDixonSpectralFlux(fluxConfiguration(new Float64Array(8), { hopSize: 0 })),
|
||||
RangeError,
|
||||
"hopSize must be between 1 and fftSize",
|
||||
"zero hop",
|
||||
);
|
||||
assertThrows(
|
||||
() => computeDixonSpectralFlux(fluxConfiguration(new Float64Array(8), {
|
||||
maximumOutputBytes: 127,
|
||||
})),
|
||||
RangeError,
|
||||
"maximumOutputBytes is 127",
|
||||
"pre-allocation output cap",
|
||||
);
|
||||
assertThrows(
|
||||
() => computeDixonSpectralFlux(fluxConfiguration(new Float64Array(4), {
|
||||
maximumOutputBytes: 1.5,
|
||||
})),
|
||||
RangeError,
|
||||
"maximumOutputBytes must be a positive safe integer",
|
||||
"invalid output cap",
|
||||
);
|
||||
assertThrows(
|
||||
() => pickCausalSpectralFluxPeaks(Float64Array.of(0, 1), {
|
||||
delta: 0.1,
|
||||
preMaxFrames: 1,
|
||||
preMeanFrames: 1,
|
||||
}),
|
||||
TypeError,
|
||||
"refractoryFrames must be provided explicitly",
|
||||
"missing peak-picker parameter",
|
||||
);
|
||||
assertThrows(
|
||||
() => pickCausalSpectralFluxPeaks(Float64Array.of(0, 1), {
|
||||
delta: 0.1,
|
||||
preMaxFrames: -1,
|
||||
preMeanFrames: 1,
|
||||
refractoryFrames: 1,
|
||||
}),
|
||||
RangeError,
|
||||
"preMaxFrames must be a non-negative safe integer",
|
||||
"negative peak-picker window",
|
||||
);
|
||||
});
|
||||
|
||||
test("spectral flux와 causal peak picker는 같은 입력에서 결정적이다", () => {
|
||||
const samples = Float64Array.of(
|
||||
0, 0.25, -0.5, 0.75,
|
||||
0.5, -0.25, 0.125, -0.625,
|
||||
-0.5, 0.25, 0.75, -0.125,
|
||||
);
|
||||
const untouched = Float64Array.from(samples);
|
||||
const options = {
|
||||
samples,
|
||||
sampleRate: 8,
|
||||
fftSize: 4,
|
||||
hopSize: 2,
|
||||
channelId: "determinism-channel",
|
||||
};
|
||||
const first = computeDixonSpectralFlux(options);
|
||||
const second = computeDixonSpectralFlux(options);
|
||||
|
||||
assertArrayExact(samples, untouched, "input samples remain unchanged");
|
||||
assertArrayExact(first.rawOdf, second.rawOdf, "deterministic raw ODF");
|
||||
assertArrayExact(
|
||||
first.positiveDifferences,
|
||||
second.positiveDifferences,
|
||||
"deterministic per-bin differences",
|
||||
);
|
||||
assertEqual(JSON.stringify(first), JSON.stringify(second), "deterministic metadata");
|
||||
|
||||
const pickerOptions = {
|
||||
delta: 0.01,
|
||||
preMaxFrames: 2,
|
||||
preMeanFrames: 3,
|
||||
refractoryFrames: 1,
|
||||
};
|
||||
const firstPeaks = pickCausalSpectralFluxPeaks(first.rawOdf, pickerOptions);
|
||||
const secondPeaks = pickCausalSpectralFluxPeaks(first.rawOdf, pickerOptions);
|
||||
assertEqual(JSON.stringify(firstPeaks), JSON.stringify(secondPeaks), "deterministic peaks");
|
||||
});
|
||||
Reference in New Issue
Block a user