581 lines
22 KiB
JavaScript
581 lines
22 KiB
JavaScript
export const MAX_MICROPHONES = 1024;
|
||
export const APERTURE_SHAPES = Object.freeze(["rectangle", "ellipse"]);
|
||
export const PRESET_TYPES = Object.freeze(["grid", "linear", "ring", "spiral", "random"]);
|
||
|
||
const COORDINATE_SYSTEM = Object.freeze({
|
||
handedness: "right",
|
||
xAxis: "right",
|
||
yAxis: "up",
|
||
zAxis: "toward-scene",
|
||
});
|
||
const GOLDEN_ANGLE = Math.PI * (3 - Math.sqrt(5));
|
||
const COORDINATE_DIGITS = 9;
|
||
|
||
function finiteNumber(value, label) {
|
||
const number = Number(value);
|
||
if (!Number.isFinite(number)) throw new TypeError(label + "은(는) 유한한 숫자여야 합니다.");
|
||
return number;
|
||
}
|
||
|
||
function positiveDimension(value, label) {
|
||
const number = finiteNumber(value, label);
|
||
if (number <= 0 || number > 20) throw new RangeError(label + "은(는) 0보다 크고 20 m 이하여야 합니다.");
|
||
return number;
|
||
}
|
||
|
||
function boundedInteger(value, label, minimum, maximum) {
|
||
const number = Number(value);
|
||
if (!Number.isInteger(number) || number < minimum || number > maximum) {
|
||
throw new RangeError(label + "은(는) " + minimum + "–" + maximum + " 정수여야 합니다.");
|
||
}
|
||
return number;
|
||
}
|
||
|
||
function normalizedShape(shape) {
|
||
return APERTURE_SHAPES.includes(shape) ? shape : "rectangle";
|
||
}
|
||
|
||
function rounded(value) {
|
||
const number = Number(finiteNumber(value, "좌표").toFixed(COORDINATE_DIGITS));
|
||
return Object.is(number, -0) ? 0 : number;
|
||
}
|
||
|
||
function normalizedPosition(position) {
|
||
if (!Array.isArray(position) || position.length !== 3) {
|
||
throw new TypeError("마이크 위치는 [x, y, z] 숫자 3개여야 합니다.");
|
||
}
|
||
return position.map(rounded);
|
||
}
|
||
|
||
function normalizedAperture(aperture) {
|
||
return {
|
||
width: positiveDimension(aperture?.width, "aperture width"),
|
||
height: positiveDimension(aperture?.height, "aperture height"),
|
||
};
|
||
}
|
||
|
||
function microphoneId(index) {
|
||
return "mic-" + String(index).padStart(3, "0");
|
||
}
|
||
|
||
function microphoneFromPosition(position, index) {
|
||
return { id: microphoneId(index + 1), position: normalizedPosition(position) };
|
||
}
|
||
|
||
function pointKey(position) {
|
||
return position.map((value) => {
|
||
const number = finiteNumber(value, "좌표");
|
||
return Object.is(number, -0) ? "0" : String(number);
|
||
}).join(",");
|
||
}
|
||
|
||
function linearValue(index, count, minimum, maximum) {
|
||
if (count === 1) return (minimum + maximum) / 2;
|
||
return minimum + (index / (count - 1)) * (maximum - minimum);
|
||
}
|
||
|
||
function presetBounds(aperture, edgeInsetM) {
|
||
const dimensions = normalizedAperture(aperture);
|
||
const inset = finiteNumber(edgeInsetM ?? 0, "경계 여백");
|
||
if (inset < 0 || inset * 2 >= Math.min(dimensions.width, dimensions.height)) {
|
||
throw new RangeError("경계 여백은 0 이상이고 짧은 aperture 변의 절반보다 작아야 합니다.");
|
||
}
|
||
return {
|
||
width: dimensions.width,
|
||
height: dimensions.height,
|
||
halfWidth: dimensions.width / 2 - inset,
|
||
halfHeight: dimensions.height / 2 - inset,
|
||
};
|
||
}
|
||
|
||
function gridPositions(options, bounds, shape) {
|
||
const columns = boundedInteger(options.columns ?? 4, "Columns", 1, MAX_MICROPHONES);
|
||
const rows = boundedInteger(options.rows ?? 3, "Rows", 1, MAX_MICROPHONES);
|
||
if (columns * rows > MAX_MICROPHONES) {
|
||
throw new RangeError("격자 마이크는 최대 " + MAX_MICROPHONES + "개까지 생성할 수 있습니다.");
|
||
}
|
||
const positions = [];
|
||
for (let row = 0; row < rows; row += 1) {
|
||
if (shape === "ellipse") {
|
||
const normalizedY = rows === 1 ? 0 : -1 + (2 * (row + 0.5)) / rows;
|
||
const y = normalizedY * bounds.halfHeight;
|
||
const rowHalfWidth = bounds.halfWidth * Math.sqrt(Math.max(0, 1 - normalizedY * normalizedY));
|
||
for (let column = 0; column < columns; column += 1) {
|
||
const normalizedX = columns === 1 ? 0 : -1 + (2 * (column + 0.5)) / columns;
|
||
positions.push([normalizedX * rowHalfWidth, y, 0]);
|
||
}
|
||
} else {
|
||
const y = linearValue(row, rows, -bounds.halfHeight, bounds.halfHeight);
|
||
for (let column = 0; column < columns; column += 1) {
|
||
positions.push([
|
||
linearValue(column, columns, -bounds.halfWidth, bounds.halfWidth),
|
||
y,
|
||
0,
|
||
]);
|
||
}
|
||
}
|
||
}
|
||
return positions;
|
||
}
|
||
|
||
function linearPositions(options, bounds, shape) {
|
||
const count = boundedInteger(options.count ?? 8, "마이크 수", 1, MAX_MICROPHONES);
|
||
const axis = ["x", "y", "diagonal"].includes(options.axis) ? options.axis : "x";
|
||
return Array.from({ length: count }, (_, index) => {
|
||
const ratio = count === 1 ? 0.5 : index / (count - 1);
|
||
if (axis === "y") return [0, -bounds.halfHeight + ratio * bounds.halfHeight * 2, 0];
|
||
if (axis === "diagonal") {
|
||
const extent = shape === "ellipse" ? Math.SQRT1_2 : 1;
|
||
return [
|
||
(-bounds.halfWidth + ratio * bounds.halfWidth * 2) * extent,
|
||
(-bounds.halfHeight + ratio * bounds.halfHeight * 2) * extent,
|
||
0,
|
||
];
|
||
}
|
||
return [-bounds.halfWidth + ratio * bounds.halfWidth * 2, 0, 0];
|
||
});
|
||
}
|
||
|
||
function rectanglePerimeterPosition(ratio, halfWidth, halfHeight) {
|
||
const width = halfWidth * 2;
|
||
const height = halfHeight * 2;
|
||
const perimeter = 2 * (width + height);
|
||
let distance = ratio * perimeter;
|
||
if (distance <= width) return [-halfWidth + distance, -halfHeight, 0];
|
||
distance -= width;
|
||
if (distance <= height) return [halfWidth, -halfHeight + distance, 0];
|
||
distance -= height;
|
||
if (distance <= width) return [halfWidth - distance, halfHeight, 0];
|
||
distance -= width;
|
||
return [-halfWidth, halfHeight - distance, 0];
|
||
}
|
||
|
||
function ringPositions(options, bounds, shape) {
|
||
const count = boundedInteger(options.count ?? 16, "마이크 수", 1, MAX_MICROPHONES);
|
||
if (count === 1) return [[0, 0, 0]];
|
||
return Array.from({ length: count }, (_, index) => {
|
||
const ratio = index / count;
|
||
if (shape === "rectangle") {
|
||
return rectanglePerimeterPosition(ratio, bounds.halfWidth, bounds.halfHeight);
|
||
}
|
||
const angle = ratio * Math.PI * 2;
|
||
return [bounds.halfWidth * Math.cos(angle), bounds.halfHeight * Math.sin(angle), 0];
|
||
});
|
||
}
|
||
|
||
function spiralPositions(options, bounds) {
|
||
const count = boundedInteger(options.count ?? 32, "마이크 수", 1, MAX_MICROPHONES);
|
||
return Array.from({ length: count }, (_, index) => {
|
||
const radius = Math.sqrt((index + 0.5) / count);
|
||
const angle = index * GOLDEN_ANGLE;
|
||
return [
|
||
bounds.halfWidth * radius * Math.cos(angle),
|
||
bounds.halfHeight * radius * Math.sin(angle),
|
||
0,
|
||
];
|
||
});
|
||
}
|
||
|
||
function createSeededRandom(seedValue) {
|
||
let seed = Number(seedValue);
|
||
if (!Number.isFinite(seed)) seed = 1;
|
||
let state = Math.trunc(seed) >>> 0;
|
||
return () => {
|
||
state = (state + 0x6d2b79f5) >>> 0;
|
||
let value = state;
|
||
value = Math.imul(value ^ (value >>> 15), value | 1);
|
||
value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
|
||
return ((value ^ (value >>> 14)) >>> 0) / 4294967296;
|
||
};
|
||
}
|
||
|
||
function randomCandidate(random, bounds, shape) {
|
||
if (shape === "ellipse") {
|
||
const radius = Math.sqrt(random());
|
||
const angle = random() * Math.PI * 2;
|
||
return [
|
||
bounds.halfWidth * radius * Math.cos(angle),
|
||
bounds.halfHeight * radius * Math.sin(angle),
|
||
0,
|
||
];
|
||
}
|
||
return [
|
||
(random() * 2 - 1) * bounds.halfWidth,
|
||
(random() * 2 - 1) * bounds.halfHeight,
|
||
0,
|
||
];
|
||
}
|
||
|
||
function squaredDistance(left, right) {
|
||
const dx = left[0] - right[0];
|
||
const dy = left[1] - right[1];
|
||
const dz = left[2] - right[2];
|
||
return dx * dx + dy * dy + dz * dz;
|
||
}
|
||
|
||
function randomPositions(options, bounds, shape) {
|
||
const count = boundedInteger(options.count ?? 32, "마이크 수", 1, MAX_MICROPHONES);
|
||
const minimumSpacing = finiteNumber(options.minimumSpacingM ?? 0, "최소 간격");
|
||
if (minimumSpacing < 0) throw new RangeError("최소 간격은 0 이상이어야 합니다.");
|
||
const minimumSpacingSquared = minimumSpacing * minimumSpacing;
|
||
const random = createSeededRandom(options.seed ?? 1);
|
||
const positions = [];
|
||
const keys = new Set();
|
||
const cellSize = Math.max(minimumSpacing, 10 ** -COORDINATE_DIGITS);
|
||
const spatialCells = minimumSpacingSquared > 0 ? new Map() : null;
|
||
const cellCoordinates = (position) => [
|
||
Math.floor(position[0] / cellSize),
|
||
Math.floor(position[1] / cellSize),
|
||
];
|
||
const cellKey = (x, y) => String(x) + "," + String(y);
|
||
const violatesMinimumSpacing = (candidate) => {
|
||
if (!spatialCells) return false;
|
||
const [cellX, cellY] = cellCoordinates(candidate);
|
||
for (let offsetY = -1; offsetY <= 1; offsetY += 1) {
|
||
for (let offsetX = -1; offsetX <= 1; offsetX += 1) {
|
||
const neighbors = spatialCells.get(cellKey(cellX + offsetX, cellY + offsetY));
|
||
if (neighbors?.some(
|
||
(position) => squaredDistance(position, candidate) < minimumSpacingSquared,
|
||
)) return true;
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
const indexPosition = (position) => {
|
||
if (!spatialCells) return;
|
||
const [cellX, cellY] = cellCoordinates(position);
|
||
const key = cellKey(cellX, cellY);
|
||
const cell = spatialCells.get(key);
|
||
if (cell) cell.push(position);
|
||
else spatialCells.set(key, [position]);
|
||
};
|
||
const maximumAttempts = Math.max(2000, count * 150);
|
||
for (let attempt = 0; attempt < maximumAttempts && positions.length < count; attempt += 1) {
|
||
const candidate = normalizedPosition(randomCandidate(random, bounds, shape));
|
||
const key = pointKey(candidate);
|
||
if (keys.has(key)) continue;
|
||
if (violatesMinimumSpacing(candidate)) continue;
|
||
keys.add(key);
|
||
positions.push(candidate);
|
||
indexPosition(candidate);
|
||
}
|
||
if (positions.length !== count) {
|
||
throw new RangeError(
|
||
"지정한 aperture와 최소 간격으로 " + count +
|
||
"개를 배치할 수 없습니다. 마이크 수나 최소 간격을 줄이세요.",
|
||
);
|
||
}
|
||
return positions;
|
||
}
|
||
|
||
export function sanitizeArrayId(value, fallback = "custom-array") {
|
||
const sanitized = String(value ?? "")
|
||
.toLowerCase()
|
||
.normalize("NFKD")
|
||
.replace(/[^a-z0-9._-]+/g, "-")
|
||
.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, "");
|
||
return sanitized || fallback;
|
||
}
|
||
|
||
export function safeArrayFileStem(arrayDefinition) {
|
||
return sanitizeArrayId(arrayDefinition?.id || arrayDefinition?.name, "microphone-array");
|
||
}
|
||
|
||
export function generatePresetMicrophones(options = {}) {
|
||
const shape = normalizedShape(options.shape);
|
||
const bounds = presetBounds(options.aperture, options.edgeInsetM);
|
||
let positions;
|
||
if (options.type === "linear") positions = linearPositions(options, bounds, shape);
|
||
else if (options.type === "ring") positions = ringPositions(options, bounds, shape);
|
||
else if (options.type === "spiral") positions = spiralPositions(options, bounds);
|
||
else if (options.type === "random") positions = randomPositions(options, bounds, shape);
|
||
else positions = gridPositions(options, bounds, shape);
|
||
return positions.map(microphoneFromPosition);
|
||
}
|
||
|
||
export function createArrayDefinition(options = {}) {
|
||
const aperture = normalizedAperture({
|
||
width: options.width ?? 0.45,
|
||
height: options.height ?? 0.45,
|
||
});
|
||
const arrayDefinition = {
|
||
schemaVersion: "1.0.0",
|
||
kind: "micarrsim.array",
|
||
id: sanitizeArrayId(options.id ?? "custom-array"),
|
||
name: String(options.name ?? "Custom 4x3 array"),
|
||
description: String(options.description ?? "Array Builder에서 생성한 사용자 마이크 배열"),
|
||
units: "m",
|
||
coordinateSystem: { ...COORDINATE_SYSTEM },
|
||
aperture,
|
||
microphones: [],
|
||
};
|
||
arrayDefinition.microphones = generatePresetMicrophones({
|
||
type: options.presetType ?? "grid",
|
||
aperture,
|
||
shape: options.shape ?? "rectangle",
|
||
columns: options.columns ?? 4,
|
||
rows: options.rows ?? 3,
|
||
count: options.count,
|
||
seed: options.seed,
|
||
minimumSpacingM: options.minimumSpacingM,
|
||
edgeInsetM: options.edgeInsetM,
|
||
axis: options.axis,
|
||
});
|
||
return arrayDefinition;
|
||
}
|
||
|
||
export function prepareArrayForEditing(value) {
|
||
if (!value || typeof value !== "object" || Array.isArray(value)) {
|
||
throw new TypeError("Array 문서 객체가 필요합니다.");
|
||
}
|
||
return structuredClone(value);
|
||
}
|
||
|
||
export function inferApertureShape(arrayDefinition) {
|
||
const shapeWords = [
|
||
arrayDefinition?.id,
|
||
arrayDefinition?.name,
|
||
arrayDefinition?.description,
|
||
].filter(Boolean).join(" ");
|
||
return /(^|[^a-z])(circle|circular|ellipse|elliptic|ring|spiral)([^a-z]|$)/i.test(shapeWords)
|
||
? "ellipse"
|
||
: "rectangle";
|
||
}
|
||
|
||
export function nextMicrophoneId(arrayDefinition) {
|
||
const used = new Set((arrayDefinition?.microphones ?? []).map((microphone) => microphone.id));
|
||
let maximumSuffix = 0n;
|
||
for (const id of used) {
|
||
const match = /^mic-(\d+)$/.exec(id);
|
||
if (!match) continue;
|
||
const suffix = BigInt(match[1]);
|
||
if (suffix > maximumSuffix) maximumSuffix = suffix;
|
||
}
|
||
let candidate = maximumSuffix + 1n;
|
||
for (let attempt = 0; attempt <= used.size; attempt += 1) {
|
||
const id = "mic-" + candidate.toString().padStart(3, "0");
|
||
if (id.length <= 64 && !used.has(id)) return id;
|
||
candidate += 1n;
|
||
}
|
||
for (let suffix = 1; suffix <= MAX_MICROPHONES + 1; suffix += 1) {
|
||
const id = microphoneId(suffix);
|
||
if (!used.has(id)) return id;
|
||
}
|
||
throw new Error("사용 가능한 마이크 ID를 찾을 수 없습니다.");
|
||
}
|
||
|
||
export function addMicrophone(arrayDefinition, position, properties = {}) {
|
||
if (arrayDefinition.microphones.length >= MAX_MICROPHONES) {
|
||
throw new RangeError("마이크는 최대 " + MAX_MICROPHONES + "개까지 추가할 수 있습니다.");
|
||
}
|
||
const microphone = {
|
||
id: properties.id || nextMicrophoneId(arrayDefinition),
|
||
position: normalizedPosition(position),
|
||
};
|
||
for (const key of ["sensitivityDb", "phaseOffsetDeg", "frequencyResponse"]) {
|
||
if (properties[key] !== undefined) microphone[key] = structuredClone(properties[key]);
|
||
}
|
||
arrayDefinition.microphones.push(microphone);
|
||
return microphone;
|
||
}
|
||
|
||
export function updateMicrophone(arrayDefinition, microphoneIdValue, changes) {
|
||
const microphone = arrayDefinition.microphones.find((item) => item.id === microphoneIdValue);
|
||
if (!microphone) throw new Error("마이크를 찾을 수 없습니다: " + microphoneIdValue);
|
||
if (changes.id !== undefined && changes.id !== microphone.id) {
|
||
const nextId = String(changes.id).trim();
|
||
if (!nextId) throw new Error("마이크 ID는 비어 있을 수 없습니다.");
|
||
if (arrayDefinition.microphones.some((item) => item !== microphone && item.id === nextId)) {
|
||
throw new Error("이미 사용 중인 마이크 ID입니다: " + nextId);
|
||
}
|
||
microphone.id = nextId;
|
||
}
|
||
if (changes.position !== undefined) microphone.position = normalizedPosition(changes.position);
|
||
for (const key of ["sensitivityDb", "phaseOffsetDeg"]) {
|
||
if (!Object.hasOwn(changes, key)) continue;
|
||
if (changes[key] === null || changes[key] === "") delete microphone[key];
|
||
else microphone[key] = finiteNumber(changes[key], key);
|
||
}
|
||
return microphone;
|
||
}
|
||
|
||
export function removeMicrophone(arrayDefinition, microphoneIdValue) {
|
||
if (arrayDefinition.microphones.length <= 1) return false;
|
||
const index = arrayDefinition.microphones.findIndex((item) => item.id === microphoneIdValue);
|
||
if (index < 0) return false;
|
||
arrayDefinition.microphones.splice(index, 1);
|
||
return true;
|
||
}
|
||
|
||
export function moveMicrophone(arrayDefinition, microphoneIdValue, delta) {
|
||
const index = arrayDefinition.microphones.findIndex((item) => item.id === microphoneIdValue);
|
||
if (index < 0) return false;
|
||
const target = Math.max(0, Math.min(arrayDefinition.microphones.length - 1, index + delta));
|
||
if (target === index) return false;
|
||
const [microphone] = arrayDefinition.microphones.splice(index, 1);
|
||
arrayDefinition.microphones.splice(target, 0, microphone);
|
||
return true;
|
||
}
|
||
|
||
export function replaceMicrophonesWithPreset(arrayDefinition, options) {
|
||
const microphones = generatePresetMicrophones({
|
||
...options,
|
||
aperture: options?.aperture ?? arrayDefinition.aperture,
|
||
});
|
||
arrayDefinition.microphones = microphones;
|
||
return microphones;
|
||
}
|
||
|
||
export function positionInsideAperture(position, aperture, shape = "rectangle", tolerance = 1e-8) {
|
||
const dimensions = normalizedAperture(aperture);
|
||
const normalized = normalizedPosition(position);
|
||
const halfWidth = dimensions.width / 2;
|
||
const halfHeight = dimensions.height / 2;
|
||
if (normalizedShape(shape) === "ellipse") {
|
||
const radiusSquared =
|
||
(normalized[0] * normalized[0]) / (halfWidth * halfWidth) +
|
||
(normalized[1] * normalized[1]) / (halfHeight * halfHeight);
|
||
return radiusSquared <= 1 + tolerance;
|
||
}
|
||
return Math.abs(normalized[0]) <= halfWidth + tolerance &&
|
||
Math.abs(normalized[1]) <= halfHeight + tolerance;
|
||
}
|
||
|
||
export function clampPositionToAperture(position, aperture, shape = "rectangle") {
|
||
const dimensions = normalizedAperture(aperture);
|
||
const normalized = normalizedPosition(position);
|
||
const halfWidth = dimensions.width / 2;
|
||
const halfHeight = dimensions.height / 2;
|
||
if (normalizedShape(shape) === "ellipse") {
|
||
const radius = Math.hypot(normalized[0] / halfWidth, normalized[1] / halfHeight);
|
||
if (radius > 1) {
|
||
normalized[0] /= radius;
|
||
normalized[1] /= radius;
|
||
}
|
||
} else {
|
||
normalized[0] = Math.max(-halfWidth, Math.min(halfWidth, normalized[0]));
|
||
normalized[1] = Math.max(-halfHeight, Math.min(halfHeight, normalized[1]));
|
||
}
|
||
return normalized.map(rounded);
|
||
}
|
||
|
||
export function snapPosition(position, stepM, aperture, shape = "rectangle") {
|
||
const step = finiteNumber(stepM, "snap 간격");
|
||
const normalized = normalizedPosition(position);
|
||
if (step > 0) {
|
||
normalized[0] = Math.round(normalized[0] / step) * step;
|
||
normalized[1] = Math.round(normalized[1] / step) * step;
|
||
normalized[2] = Math.round(normalized[2] / step) * step;
|
||
}
|
||
return aperture
|
||
? clampPositionToAperture(normalized, aperture, shape)
|
||
: normalized.map(rounded);
|
||
}
|
||
|
||
export function centerMicrophones(arrayDefinition) {
|
||
const microphones = arrayDefinition.microphones;
|
||
if (microphones.length === 0) return [0, 0, 0];
|
||
const centroid = [0, 1, 2].map((axis) =>
|
||
microphones.reduce((sum, microphone) => sum + microphone.position[axis], 0) / microphones.length);
|
||
for (const microphone of microphones) {
|
||
microphone.position = microphone.position.map((value, axis) => rounded(value - centroid[axis]));
|
||
}
|
||
return centroid;
|
||
}
|
||
|
||
export function fitApertureToMicrophones(arrayDefinition, options = {}) {
|
||
const microphones = arrayDefinition.microphones;
|
||
if (microphones.length === 0) return arrayDefinition.aperture;
|
||
const padding = Math.max(0, finiteNumber(options.paddingM ?? 0.005, "aperture 여백"));
|
||
const minimumSize = Math.max(0.000001, finiteNumber(options.minimumSizeM ?? 0.001, "최소 aperture"));
|
||
const maximumX = Math.max(...microphones.map((microphone) => Math.abs(microphone.position[0])));
|
||
const maximumY = Math.max(...microphones.map((microphone) => Math.abs(microphone.position[1])));
|
||
let width = Math.max(minimumSize, maximumX * 2);
|
||
let height = Math.max(minimumSize, maximumY * 2);
|
||
if (normalizedShape(options.shape) === "ellipse") {
|
||
let maximumRadius = 0;
|
||
for (const microphone of microphones) {
|
||
maximumRadius = Math.max(
|
||
maximumRadius,
|
||
Math.hypot(
|
||
(2 * microphone.position[0]) / width,
|
||
(2 * microphone.position[1]) / height,
|
||
),
|
||
);
|
||
}
|
||
if (maximumRadius > 1) {
|
||
width *= maximumRadius;
|
||
height *= maximumRadius;
|
||
}
|
||
}
|
||
arrayDefinition.aperture.width = rounded(Math.min(20, width + padding * 2));
|
||
arrayDefinition.aperture.height = rounded(Math.min(20, height + padding * 2));
|
||
return arrayDefinition.aperture;
|
||
}
|
||
|
||
export function arrayGeometryIssues(arrayDefinition, options = {}) {
|
||
const issues = [];
|
||
const shape = normalizedShape(options.shape);
|
||
const positions = new Map();
|
||
for (let index = 0; index < arrayDefinition.microphones.length; index += 1) {
|
||
const microphone = arrayDefinition.microphones[index];
|
||
const key = pointKey(microphone.position);
|
||
if (positions.has(key)) {
|
||
issues.push({
|
||
severity: "error",
|
||
path: "$.microphones[" + index + "].position",
|
||
message: microphone.id + "와 " + positions.get(key) + "의 위치가 중복됩니다.",
|
||
});
|
||
} else {
|
||
positions.set(key, microphone.id);
|
||
}
|
||
if (!positionInsideAperture(microphone.position, arrayDefinition.aperture, shape)) {
|
||
issues.push({
|
||
severity: "warning",
|
||
path: "$.microphones[" + index + "].position",
|
||
message: microphone.id + "가 " + shape + " 생성 경계 밖에 있습니다.",
|
||
});
|
||
}
|
||
}
|
||
return issues;
|
||
}
|
||
|
||
export function arrayStatistics(arrayDefinition) {
|
||
const microphones = arrayDefinition.microphones;
|
||
if (microphones.length === 0) {
|
||
return { count: 0, centroid: [0, 0, 0], minimumSpacing: null, calibrationCount: 0 };
|
||
}
|
||
const centroid = [0, 1, 2].map((axis) => {
|
||
const scale = microphones.reduce(
|
||
(maximum, microphone) => Math.max(maximum, Math.abs(microphone.position[axis])),
|
||
0,
|
||
);
|
||
if (scale === 0) return 0;
|
||
const normalizedSum = microphones.reduce(
|
||
(sum, microphone) => sum + microphone.position[axis] / scale,
|
||
0,
|
||
);
|
||
const normalizedMean = Math.max(-1, Math.min(1, normalizedSum / microphones.length));
|
||
return normalizedMean * scale;
|
||
});
|
||
let minimumSpacingSquared = Infinity;
|
||
for (let left = 0; left < microphones.length; left += 1) {
|
||
for (let right = left + 1; right < microphones.length; right += 1) {
|
||
minimumSpacingSquared = Math.min(
|
||
minimumSpacingSquared,
|
||
squaredDistance(microphones[left].position, microphones[right].position),
|
||
);
|
||
}
|
||
}
|
||
const calibrationCount = microphones.filter((microphone) =>
|
||
microphone.sensitivityDb !== undefined ||
|
||
microphone.phaseOffsetDeg !== undefined ||
|
||
microphone.frequencyResponse !== undefined).length;
|
||
return {
|
||
count: microphones.length,
|
||
centroid: centroid.map(rounded),
|
||
minimumSpacing: Number.isFinite(minimumSpacingSquared) ? Math.sqrt(minimumSpacingSquared) : null,
|
||
calibrationCount,
|
||
};
|
||
}
|