279 lines
16 KiB
JavaScript
279 lines
16 KiB
JavaScript
"use strict";
|
|
|
|
const fs = require("fs");
|
|
const path = require("path");
|
|
const { BUDGETS } = require("./stage-manifest");
|
|
|
|
function readAreaConfig(file, options = {}) {
|
|
if (!fs.existsSync(file)) {
|
|
throw new Error(`Config file not found: ${file}`);
|
|
}
|
|
return normalizeAreaConfig(JSON.parse(fs.readFileSync(file, "utf8")), options);
|
|
}
|
|
|
|
function normalizeAreaConfig(raw, options = {}) {
|
|
const repoRoot = options.repoRoot || path.resolve(__dirname, "..", "..");
|
|
const id = requireText(raw.id, "id");
|
|
const input = path.resolve(requireText(raw.input, "input"));
|
|
if (!fs.existsSync(input)) {
|
|
throw new Error(`Input OSM XML not found: ${input}`);
|
|
}
|
|
|
|
const outputRoot = path.resolve(raw.outputRoot || path.join(repoRoot, "outputs"));
|
|
const outputOverrides = raw.outputs || {};
|
|
const areaDir = path.resolve(outputOverrides.areaDir || path.join(outputRoot, id));
|
|
const fileStem = outputOverrides.fileStem || id;
|
|
const compress = normalizeCompressConfig(raw.compress);
|
|
const budget = normalizeBudgetConfig(raw.budget);
|
|
const pipelineDir = path.resolve(outputOverrides.pipelineDir || path.join(areaDir, "_pipeline"));
|
|
const packageDir = path.resolve(outputOverrides.packageDir || path.join(areaDir, "package"));
|
|
const packageStagingDir = path.resolve(outputOverrides.packageStagingDir || path.join(pipelineDir, "package-staging"));
|
|
const packageRuntimeDir = path.resolve(outputOverrides.packageRuntimeDir || path.join(packageDir, "runtime"));
|
|
const packageStagingRuntimeDir = path.resolve(outputOverrides.packageStagingRuntimeDir || path.join(packageStagingDir, "runtime"));
|
|
const previewDir = path.resolve(outputOverrides.previewDir || path.join(areaDir, "_preview"));
|
|
const geojsonDir = path.resolve(outputOverrides.geojsonDir || path.join(areaDir, "osm2streets_web_out"));
|
|
const nativeRoadDir = path.resolve(outputOverrides.nativeRoadDir || path.join(areaDir, "native-road"));
|
|
const outputs = {
|
|
areaDir,
|
|
geojsonDir,
|
|
nativeRoadDir,
|
|
nativeRoadOverrides: path.resolve(outputOverrides.nativeRoadOverrides || path.join(areaDir, "native-road-overrides.json")),
|
|
nativeTrafficSignals: path.resolve(outputOverrides.nativeTrafficSignals || path.join(areaDir, "native-traffic-signals.json")),
|
|
gpkg: path.resolve(outputOverrides.gpkg || path.join(areaDir, `${fileStem}.gpkg`)),
|
|
qgisProject: path.resolve(outputOverrides.qgisProject || path.join(areaDir, `${fileStem}.qgz`)),
|
|
qgisPreview: path.resolve(outputOverrides.qgisPreview || path.join(areaDir, `${fileStem}-preview.png`)),
|
|
blend: path.resolve(outputOverrides.blend || path.join(areaDir, `${fileStem}.blend`)),
|
|
render: path.resolve(outputOverrides.render || path.join(areaDir, `${fileStem}.png`)),
|
|
// Published static assets are staged first and promoted by the package stage.
|
|
packageDir,
|
|
packageStagingDir,
|
|
packageManifest: path.resolve(outputOverrides.packageManifest || path.join(packageDir, "manifest.json")),
|
|
packageStagingManifest: path.resolve(outputOverrides.packageStagingManifest || path.join(packageStagingDir, "manifest.json")),
|
|
packageModelDir: path.resolve(outputOverrides.packageModelDir || path.join(packageDir, "models")),
|
|
packageStagingModelDir: path.resolve(outputOverrides.packageStagingModelDir || path.join(packageStagingDir, "models")),
|
|
packagePrimaryGlb: path.resolve(outputOverrides.packagePrimaryGlb || path.join(packageDir, "models", `${fileStem}.glb`)),
|
|
glb: path.resolve(outputOverrides.glb || path.join(packageStagingDir, "models", `${fileStem}.glb`)),
|
|
packageRuntimeDir,
|
|
packageStagingRuntimeDir,
|
|
trafficSignalsDynamicGlb: path.resolve(outputOverrides.trafficSignalsDynamicGlb || path.join(packageStagingRuntimeDir, "traffic-signals-dynamic.glb")),
|
|
trafficSignalsCountdown0Glb: path.resolve(outputOverrides.trafficSignalsCountdown0Glb || path.join(packageStagingRuntimeDir, "traffic-signals-countdown-0.glb")),
|
|
trafficSignalsCountdown1Glb: path.resolve(outputOverrides.trafficSignalsCountdown1Glb || path.join(packageStagingRuntimeDir, "traffic-signals-countdown-1.glb")),
|
|
packageTrafficSignals: path.resolve(outputOverrides.packageTrafficSignals || path.join(packageRuntimeDir, "traffic-signals.json")),
|
|
packageStagingTrafficSignals: path.resolve(outputOverrides.packageStagingTrafficSignals || path.join(packageStagingRuntimeDir, "traffic-signals.json")),
|
|
metadata: path.resolve(outputOverrides.metadata || path.join(packageStagingDir, "manifest.json")),
|
|
cesiumPreview: path.resolve(
|
|
outputOverrides.cesiumPreview || path.join(areaDir, `${fileStem}-cesium-preview.html`),
|
|
),
|
|
previewDir,
|
|
previewDescriptor: path.resolve(outputOverrides.previewDescriptor || path.join(previewDir, "descriptor.json")),
|
|
trafficSimulation: path.resolve(outputOverrides.trafficSimulation || path.join(previewDir, `${fileStem}-traffic-simulation.json`)),
|
|
vehicleRoute: path.resolve(outputOverrides.vehicleRoute || path.join(previewDir, `${fileStem}-vehicle-route.json`)),
|
|
vehicleModel: path.resolve(outputOverrides.vehicleModel || path.join(previewDir, `${fileStem}-vehicle-car.gltf`)),
|
|
trafficSignalAssemblies: path.resolve(
|
|
outputOverrides.trafficSignalAssemblies || path.join(geojsonDir, "traffic_signal_assemblies.geojson"),
|
|
),
|
|
// Runtime poses are derived from the editable assembly layer and shared by
|
|
// Blender and the browser preview.
|
|
trafficSignals: path.resolve(outputOverrides.trafficSignals || path.join(geojsonDir, "traffic_signals.json")),
|
|
pipelineDir,
|
|
stageManifestDir: path.resolve(outputOverrides.stageManifestDir || path.join(pipelineDir, "stages")),
|
|
};
|
|
|
|
return {
|
|
id,
|
|
input,
|
|
outputRoot,
|
|
qgisApp: raw.qgisApp || (process.platform === "darwin" ? "/Applications/QGIS.app" : "/usr"),
|
|
blenderApp: raw.blenderApp || (process.platform === "darwin" ? "/Applications/Blender.app" : "/usr/bin/blender"),
|
|
stages: {
|
|
// Native road compilation is the default. Legacy QGIS/osm2streets
|
|
// intermediates remain explicitly selectable for reference/debug work.
|
|
intermediates: raw.stages?.intermediates ?? raw.stages?.qgis ?? false,
|
|
blender: raw.stages?.blender ?? true,
|
|
cesium: raw.stages?.cesium ?? true,
|
|
reimport: false,
|
|
preview: true,
|
|
compress: true,
|
|
package: true,
|
|
},
|
|
qgis: {
|
|
arrowScale: raw.qgis?.arrowScale ?? raw.arrowScale ?? 0.8,
|
|
arrowMergeTriangles: raw.qgis?.arrowMergeTriangles ?? raw.arrowMergeTriangles ?? true,
|
|
arrowOutlineSimplifyMeters: raw.qgis?.arrowOutlineSimplifyMeters ?? raw.arrowOutlineSimplifyMeters ?? 0.05,
|
|
intersectionCornerSourceMaxDimensionMeters: raw.qgis?.intersectionCornerSourceMaxDimensionMeters ?? raw.intersectionCornerSourceMaxDimensionMeters ?? 2.6,
|
|
clipPad: raw.qgis?.clipPad ?? raw.clipPad ?? 0.002,
|
|
canvasPad: raw.qgis?.canvasPad ?? raw.canvasPad ?? 0.001,
|
|
previewPad: raw.qgis?.previewPad ?? raw.previewPad ?? 0.0007,
|
|
canvasExtent: raw.qgis?.canvasExtent ?? raw.canvasExtent ?? null,
|
|
previewExtent: raw.qgis?.previewExtent ?? raw.previewExtent ?? null,
|
|
layerPrefix: raw.qgis?.layerPrefix ?? raw.layerPrefix ?? "osm2streets",
|
|
},
|
|
turnLaneArrows: {
|
|
enabled: booleanOption(raw.turnLaneArrows?.enabled, false, "turnLaneArrows.enabled"),
|
|
},
|
|
nativeRoad: {
|
|
edgeLines: booleanOption(raw.nativeRoad?.edgeLines, false, "nativeRoad.edgeLines"),
|
|
junctionTemplates: normalizeJunctionTemplates(raw.nativeRoad?.junctionTemplates, repoRoot),
|
|
},
|
|
osm2streets: raw.osm2streets || {
|
|
debug_each_step: false,
|
|
dual_carriageway_experiment: false,
|
|
sidepath_zipping_experiment: false,
|
|
inferred_sidewalks: true,
|
|
osm2lanes: true,
|
|
},
|
|
blender: {
|
|
treeStyle: raw.blender?.treeStyle || "natural",
|
|
officeOverrides: raw.blender?.officeOverrides || raw.blender?.office_overrides || "",
|
|
roadProvider: roadProviderOption(raw.blender?.roadProvider ?? "native"),
|
|
},
|
|
v2xPreview: normalizeV2xPreviewConfig(raw.v2xPreview),
|
|
compress,
|
|
budget,
|
|
outputs,
|
|
};
|
|
}
|
|
|
|
function normalizeV2xPreviewConfig(raw) {
|
|
if (raw !== undefined && (raw === null || typeof raw !== "object" || Array.isArray(raw))) {
|
|
throw new Error("v2xPreview must be an object");
|
|
}
|
|
const value = raw || {};
|
|
const text = (name, fallback) => {
|
|
const item = value[name] ?? fallback;
|
|
if (typeof item !== "string") throw new Error(`v2xPreview.${name} must be a string`);
|
|
return item.trim();
|
|
};
|
|
return {
|
|
enabled: booleanOption(value.enabled, false, "v2xPreview.enabled"),
|
|
// Relative defaults keep credentials and private service origins out of the
|
|
// generated preview. Production should reverse-proxy these prefixes.
|
|
apiBaseUrl: text("apiBaseUrl", "/api"),
|
|
wsBaseUrl: text("wsBaseUrl", "/websocket"),
|
|
crossCode: text("crossCode", ""),
|
|
};
|
|
}
|
|
|
|
function normalizeJunctionTemplates(raw, repoRoot) {
|
|
if (raw === undefined || raw === null) return { enabled: false, references: [] };
|
|
if (typeof raw !== "object" || Array.isArray(raw)) throw new Error("nativeRoad.junctionTemplates must be an object");
|
|
const enabled = booleanOption(raw.enabled, false, "nativeRoad.junctionTemplates.enabled");
|
|
if (raw.references !== undefined && !Array.isArray(raw.references)) throw new Error("nativeRoad.junctionTemplates.references must be an array");
|
|
const references = (raw.references || []).map((item, index) => {
|
|
if (!item || typeof item !== "object" || Array.isArray(item)) throw new Error(`nativeRoad.junctionTemplates.references[${index}] must be an object`);
|
|
const nodeId = requireText(item.nodeId, `nativeRoad.junctionTemplates.references[${index}].nodeId`);
|
|
const template = item.template ?? "cross-v1";
|
|
if (template !== "cross-v1") throw new Error(`nativeRoad.junctionTemplates.references[${index}].template must be \"cross-v1\"`);
|
|
const referenceFile = item.referenceFile ? path.resolve(item.referenceFile) : null;
|
|
const coordinateSystem = item.coordinateSystem ?? "GCJ-02";
|
|
if (coordinateSystem !== "GCJ-02") throw new Error(`nativeRoad.junctionTemplates.references[${index}].coordinateSystem must be \"GCJ-02\"`);
|
|
const cornerRadiusMultiplier = numberOption(item.cornerRadiusMultiplier, 1, `nativeRoad.junctionTemplates.references[${index}].cornerRadiusMultiplier`, 0.75, 1.25);
|
|
const cutbackMultiplier = numberOption(item.cutbackMultiplier, 1, `nativeRoad.junctionTemplates.references[${index}].cutbackMultiplier`, 1, 1.35);
|
|
const approachWidthMultiplier = numberOption(item.approachWidthMultiplier, 1, `nativeRoad.junctionTemplates.references[${index}].approachWidthMultiplier`, 1, 1.8);
|
|
const approachLengthMeters = numberOption(item.approachLengthMeters, 24, `nativeRoad.junctionTemplates.references[${index}].approachLengthMeters`, 10, 50);
|
|
return { nodeId, template, referenceFile, coordinateSystem, cornerRadiusMultiplier, cutbackMultiplier, approachWidthMultiplier, approachLengthMeters };
|
|
});
|
|
if (raw.clusters !== undefined && !Array.isArray(raw.clusters)) throw new Error("nativeRoad.junctionTemplates.clusters must be an array");
|
|
const clusters = (raw.clusters || []).map((item, index) => {
|
|
if (!item || typeof item !== "object" || Array.isArray(item)) throw new Error(`nativeRoad.junctionTemplates.clusters[${index}] must be an object`);
|
|
const id = requireText(item.id, `nativeRoad.junctionTemplates.clusters[${index}].id`);
|
|
const nodeIds = item.nodeIds;
|
|
if (!Array.isArray(nodeIds) || nodeIds.length < 2 || nodeIds.some((value) => typeof value !== "string" && typeof value !== "number")) throw new Error(`nativeRoad.junctionTemplates.clusters[${index}].nodeIds must contain at least two node ids`);
|
|
const template = item.template ?? "complex-junction-v1";
|
|
if (template !== "cross-cluster-v1" && template !== "complex-junction-v1") throw new Error(`nativeRoad.junctionTemplates.clusters[${index}].template must be \"cross-cluster-v1\" or \"complex-junction-v1\"`);
|
|
const referenceFile = item.referenceFile ? path.resolve(item.referenceFile) : null;
|
|
const approachWidthMultiplier = numberOption(item.approachWidthMultiplier, 1.45, `nativeRoad.junctionTemplates.clusters[${index}].approachWidthMultiplier`, 1, 1.8);
|
|
const approachLengthMeters = numberOption(item.approachLengthMeters, 32, `nativeRoad.junctionTemplates.clusters[${index}].approachLengthMeters`, 10, 50);
|
|
const coreRadiusMeters = numberOption(item.coreRadiusMeters, 28, `nativeRoad.junctionTemplates.clusters[${index}].coreRadiusMeters`, 12, 80);
|
|
const cornerRadiusMeters = numberOption(item.cornerRadiusMeters, 12, `nativeRoad.junctionTemplates.clusters[${index}].cornerRadiusMeters`, 4, 25);
|
|
const outerRadiusExtraMeters = numberOption(item.outerRadiusExtraMeters, 18, `nativeRoad.junctionTemplates.clusters[${index}].outerRadiusExtraMeters`, 18, 35);
|
|
return { id, nodeIds: nodeIds.map(String), template, referenceFile, approachWidthMultiplier, approachLengthMeters, coreRadiusMeters, cornerRadiusMeters, outerRadiusExtraMeters };
|
|
});
|
|
return { enabled, references, clusters };
|
|
}
|
|
|
|
function normalizeBudgetConfig(raw) {
|
|
if (raw !== undefined && raw !== null && (typeof raw !== "object" || Array.isArray(raw))) {
|
|
throw new Error("budget must be an object");
|
|
}
|
|
const value = raw || {};
|
|
const budget = {
|
|
glbBytes: megabytesOption(value.glbSizeMb, BUDGETS.glbBytes, "budget.glbSizeMb"),
|
|
glbNodes: integerOption(value.nodes, BUDGETS.glbNodes, "budget.nodes"),
|
|
glbImages: integerOption(value.images, BUDGETS.glbImages, "budget.images"),
|
|
glbTriangles: integerOption(value.triangles, BUDGETS.glbTriangles, "budget.triangles"),
|
|
glbImageBytes: megabytesOption(value.embeddedImageBytesMb, BUDGETS.glbImageBytes, "budget.embeddedImageBytesMb"),
|
|
reason: value.reason ?? "",
|
|
};
|
|
if (typeof budget.reason !== "string") {
|
|
throw new Error("budget.reason must be a string");
|
|
}
|
|
const loosened = Object.keys(BUDGETS).some((key) => budget[key] > BUDGETS[key]);
|
|
if (loosened && budget.reason.trim() === "") {
|
|
throw new Error("budget.reason is required when a budget exceeds the default");
|
|
}
|
|
return budget;
|
|
}
|
|
|
|
function requireText(value, key) {
|
|
if (typeof value !== "string" || value.trim() === "") {
|
|
throw new Error(`Missing config key: ${key}`);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function normalizeCompressConfig(raw) {
|
|
const value = raw || {};
|
|
return {
|
|
textureSize: numberOption(value.textureSize, 768, "compress.textureSize", 64, 4096),
|
|
quality: numberOption(value.quality, 82, "compress.quality", 1, 100),
|
|
effort: numberOption(value.effort, 80, "compress.effort", 0, 100),
|
|
meshopt: booleanOption(value.meshopt, false, "compress.meshopt"),
|
|
};
|
|
}
|
|
|
|
function numberOption(value, fallback, label, min, max) {
|
|
const number = value === undefined ? fallback : Number(value);
|
|
if (!Number.isFinite(number) || number < min || number > max) {
|
|
throw new Error(`${label} must be a finite number in [${min}, ${max}]`);
|
|
}
|
|
return number;
|
|
}
|
|
|
|
function roadProviderOption(value) {
|
|
const provider = value ?? "osm2streets";
|
|
if (provider !== "osm2streets" && provider !== "native") {
|
|
throw new Error("blender.roadProvider must be \"osm2streets\" or \"native\".");
|
|
}
|
|
return provider;
|
|
}
|
|
|
|
function integerOption(value, fallback, label) {
|
|
const number = value === undefined ? fallback : Number(value);
|
|
if (!Number.isInteger(number) || number < 1) {
|
|
throw new Error(`${label} must be a positive integer`);
|
|
}
|
|
return number;
|
|
}
|
|
|
|
function megabytesOption(value, fallbackBytes, label) {
|
|
const megabytes = value === undefined ? fallbackBytes / 1024 / 1024 : Number(value);
|
|
if (!Number.isFinite(megabytes) || megabytes <= 0) {
|
|
throw new Error(`${label} must be a positive finite number`);
|
|
}
|
|
return Math.round(megabytes * 1024 * 1024);
|
|
}
|
|
|
|
function booleanOption(value, fallback, label) {
|
|
if (value === undefined) return fallback;
|
|
if (typeof value === "boolean") return value;
|
|
if (value === "true") return true;
|
|
if (value === "false") return false;
|
|
throw new Error(`${label} must be boolean`);
|
|
}
|
|
|
|
module.exports = {
|
|
normalizeAreaConfig,
|
|
readAreaConfig,
|
|
};
|