real2sim-platform/server/genesisPackage.ts
eust-w 56f124fab1
Some checks failed
CI / workbench (push) Has been cancelled
🚀 Release reproducible Real2Sim Studio alpha workbench
2026-10-28 01:13:52 +08:00

290 lines
9.9 KiB
TypeScript

import { access, copyFile, mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises'
import path from 'node:path'
import { gzipSync } from 'node:zlib'
import { assetRoot } from './assetStore.js'
import { createSimulationExport } from './flex.js'
import type { CreateFlexTaskInput, SimulationProfile } from './schemas.js'
import type { StoredTask } from './taskStore.js'
type GenesisSolver = 'fem_elastic' | 'pbd_cloth'
type GenesisParameters = {
E?: number
nu?: number
rho?: number
damping: number
stretchCompliance?: number
bendCompliance?: number
maxVolume?: number
}
export type GenesisPackageManifest = {
schema: 'real2sim.genesisPackage.v1'
taskId: string
title: string
assets: {
model: string
preview?: string
}
genesis: {
script: string
solver: GenesisSolver
material: SimulationProfile['material']
gravity: number
parameters: GenesisParameters
}
notes: string[]
generatedAt: string
}
export type GenesisPackageResult = {
packageDir: string
archivePath: string
manifest: GenesisPackageManifest
}
export const genesisPackageRoot = process.env.REAL2SIM_GENESIS_PACKAGE_ROOT
? path.resolve(process.env.REAL2SIM_GENESIS_PACKAGE_ROOT)
: path.resolve(process.env.REAL2SIM_DATA_ROOT || '.data', 'genesis-packages')
function safePathSegment(value: string) {
if (!/^[a-zA-Z0-9_-][a-zA-Z0-9._-]{0,199}$/.test(value)) throw new Error('Invalid task ID.')
return value
}
function isFlexTask(task: StoredTask): task is StoredTask & { request: CreateFlexTaskInput } {
return (task.kind === 'flex' || task.kind === 'sample') && typeof (task.request as Partial<CreateFlexTaskInput>).simulation === 'object'
}
function round(value: number, digits = 3) {
return Number(value.toFixed(digits))
}
function clamp(value: number, min: number, max: number) {
return Math.min(max, Math.max(min, value))
}
function localAssetPath(localUrl?: string) {
if (!localUrl?.startsWith('/assets/')) return undefined
const relativeParts = localUrl
.slice('/assets/'.length)
.split('/')
.filter(Boolean)
.map((part) => decodeURIComponent(part))
const resolved = path.resolve(assetRoot, ...relativeParts)
const root = path.resolve(assetRoot)
if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`)) {
throw new Error('Asset path escapes the local asset root.')
}
return resolved
}
function chooseModelAsset(task: StoredTask) {
const result = task.output?.results?.[0]
return localAssetPath(result?.local_pbr_model_url) || localAssetPath(result?.local_base_model_url) || localAssetPath(result?.local_model_url)
}
function choosePreviewAsset(task: StoredTask) {
return localAssetPath(task.output?.results?.[0]?.local_rendered_image_url)
}
async function fileExists(filePath: string) {
try {
await access(filePath)
return true
} catch {
return false
}
}
function materialParameters(simulation: SimulationProfile): { solver: GenesisSolver; parameters: GenesisParameters } {
if (simulation.material === 'cloth') {
return {
solver: 'pbd_cloth',
parameters: {
damping: round(0.001 + simulation.damping * 0.0001, 5),
stretchCompliance: Number((1e-6 / (1 + simulation.elasticity)).toPrecision(6)),
bendCompliance: Number((1e-4 / (1 + simulation.thickness)).toPrecision(6)),
},
}
}
const materialDefaults = {
silicone: { baseE: 20000, nu: 0.47, rho: 1100 },
inflatable: { baseE: 12000, nu: 0.42, rho: 260 },
softRobot: { baseE: 36000, nu: 0.4, rho: 1050 },
}[simulation.material]
return {
solver: 'fem_elastic',
parameters: {
E: Math.round(clamp(materialDefaults.baseE + simulation.elasticity * 800 - simulation.deformation * 112.5, 12000, 180000)),
nu: materialDefaults.nu,
rho: materialDefaults.rho,
damping: round(0.02 + (simulation.damping / 100) * 0.48),
maxVolume: round(clamp((simulation.thickness / 1000) ** 3, 1e-7, 5e-5), 7),
},
}
}
function packageReadme(manifest: GenesisPackageManifest) {
return `# Genesis flexible object package
Task: ${manifest.title}
## Run
\`\`\`bash
pip install -r requirements.txt
python genesis_scene.py --steps 600
# Optional: --record saves simulation.mp4; --viewer opens an interactive viewer.
\`\`\`
## Contents
- \`assets/model${path.extname(manifest.assets.model)}\`: local generated 3D asset.
- \`flex-profile.json\`: real2sim physical profile exported from the UI sliders.
- \`manifest.json\`: package metadata and Genesis parameter mapping.
- \`genesis_scene.py\`: runnable Genesis scene using \`${manifest.genesis.solver}\`.
## Important
The GLB stores geometry and visual material only. It becomes deformable in Genesis because \`genesis_scene.py\` loads it with Genesis deformable material settings. If Genesis cannot tetrahedralize the GLB for FEM, convert the model to a clean watertight OBJ and update \`assets.model\` in \`manifest.json\`. Material values are illustrative presets, not calibrated measurements. External asset rights remain with their respective owners.
`
}
async function collectFiles(dir: string, prefix = ''): Promise<Array<{ absolutePath: string; archivePath: string }>> {
const entries = await readdir(dir, { withFileTypes: true })
const files = []
for (const entry of entries) {
const absolutePath = path.join(dir, entry.name)
const archivePath = prefix ? `${prefix}/${entry.name}` : entry.name
if (entry.isDirectory()) {
files.push(...(await collectFiles(absolutePath, archivePath)))
} else if (entry.isFile()) {
files.push({ absolutePath, archivePath })
}
}
return files
}
function writeTarString(buffer: Buffer, offset: number, length: number, value: string) {
buffer.write(value.slice(0, length), offset, length, 'utf8')
}
function octal(value: number, length: number) {
return value.toString(8).padStart(length - 1, '0').slice(-(length - 1)) + '\0'
}
function tarHeader(name: string, size: number, mode = 0o644) {
const header = Buffer.alloc(512, 0)
writeTarString(header, 0, 100, name)
writeTarString(header, 100, 8, octal(mode, 8))
writeTarString(header, 108, 8, octal(0, 8))
writeTarString(header, 116, 8, octal(0, 8))
writeTarString(header, 124, 12, octal(size, 12))
writeTarString(header, 136, 12, octal(Math.floor(Date.now() / 1000), 12))
header.fill(' ', 148, 156)
header.write('0', 156)
writeTarString(header, 257, 6, 'ustar')
writeTarString(header, 263, 2, '00')
let checksum = 0
for (const byte of header) checksum += byte
writeTarString(header, 148, 8, checksum.toString(8).padStart(6, '0') + '\0 ')
return header
}
async function createTarGz(sourceDir: string, archivePath: string) {
const files = await collectFiles(sourceDir)
const chunks: Buffer[] = []
for (const file of files) {
const content = await readFile(file.absolutePath)
chunks.push(tarHeader(file.archivePath, content.length), content)
const remainder = content.length % 512
if (remainder) {
chunks.push(Buffer.alloc(512 - remainder, 0))
}
}
chunks.push(Buffer.alloc(1024, 0))
await writeFile(archivePath, gzipSync(Buffer.concat(chunks)))
}
export async function createGenesisPackage(task: StoredTask): Promise<GenesisPackageResult> {
if (!isFlexTask(task)) {
throw new Error('Genesis export requires a flex task.')
}
const modelAssetPath = chooseModelAsset(task)
if (!modelAssetPath) {
throw new Error('Genesis export requires a cached local model asset.')
}
const simulation = task.request.simulation
const genesis = materialParameters(simulation)
const taskDirName = safePathSegment(task.taskId)
const packageDir = path.join(genesisPackageRoot, taskDirName)
const assetsDir = path.join(packageDir, 'assets')
const modelExtension = path.extname(modelAssetPath) || '.glb'
const modelRelativePath = `assets/model${modelExtension}`
const archivePath = path.join(genesisPackageRoot, `${taskDirName}.tar.gz`)
const previewAssetPath = choosePreviewAsset(task)
let previewRelativePath = previewAssetPath ? `assets/preview${path.extname(previewAssetPath) || '.webp'}` : undefined
await rm(packageDir, { recursive: true, force: true })
await mkdir(assetsDir, { recursive: true })
await copyFile(modelAssetPath, path.join(packageDir, modelRelativePath))
if (previewAssetPath && previewRelativePath && (await fileExists(previewAssetPath))) {
await copyFile(previewAssetPath, path.join(packageDir, previewRelativePath))
} else {
previewRelativePath = undefined
}
const manifest: GenesisPackageManifest = {
schema: 'real2sim.genesisPackage.v1',
taskId: task.taskId,
title: task.title,
assets: {
model: modelRelativePath,
...(previewRelativePath ? { preview: previewRelativePath } : {}),
},
genesis: {
script: 'genesis_scene.py',
solver: genesis.solver,
material: simulation.material,
gravity: simulation.gravity,
parameters: genesis.parameters,
},
notes: [
'The generated GLB is a visual mesh; Genesis deformability comes from the solver and material assigned in genesis_scene.py.',
'For FEM, Genesis may need a clean watertight mesh for tetrahedralization. Convert to OBJ if the GLB cannot be retetrahedralized.',
],
generatedAt: new Date().toISOString(),
}
await writeFile(path.join(packageDir, 'manifest.json'), JSON.stringify(manifest, null, 2))
await writeFile(path.join(packageDir, 'flex-profile.json'), JSON.stringify(createSimulationExport(task.request), null, 2))
await copyFile(new URL('./genesis_scene.py', import.meta.url), path.join(packageDir, 'genesis_scene.py'))
await copyFile(new URL('./physics_metrics.py', import.meta.url), path.join(packageDir, 'physics_metrics.py'))
await copyFile(new URL('../examples/requirements.txt', import.meta.url), path.join(packageDir, 'requirements.txt'))
await writeFile(path.join(packageDir, 'README.md'), packageReadme(manifest))
await mkdir(genesisPackageRoot, { recursive: true })
await createTarGz(packageDir, archivePath)
await stat(archivePath)
return {
packageDir,
archivePath,
manifest,
}
}