Skip to content

Free Motion Capture for Everyone πŸ’€βœ¨

TypeScript

add electron old to old ui folder

jonmatthis1817cdf93b09
diff --git a/.claude/settings.local.json b/.claude/settings.local.json
new file mode 100644
index 00000000..9cc25170
--- /dev/null
+++ b/.claude/settings.local.json
@@ -0,0 +1,13 @@
+{
+ "permissions": {
+ "allow": [
+ "WebSearch",
+ "WebFetch(domain:github.com)",
+ "Bash(.venv/Scripts/python -m pytest freemocap/tests/test_http_config_endpoints.py -v --timeout=30)",
+ "Bash(.venv/Scripts/python -m pytest freemocap/tests/test_http_config_endpoints.py --timeout=30 -x)",
+ "Bash(git stash:*)",
+ "Bash(.venv/Scripts/python -m pytest freemocap/tests/ -m \"not e2e\" --timeout=30 --ignore=freemocap/tests/test_e2e_pipeline.py -q)",
+ "Bash(.venv/Scripts/python -m pytest freemocap/tests/test_http_config_endpoints.py freemocap/tests/test_schema_contract.py -q --timeout=30)"
+ ]
+ }
+}
diff --git a/freemocap-ui-old/electron-old/main/api.ts b/freemocap-ui-old/electron-old/main/api.ts
new file mode 100644
index 00000000..d7d85f7f
--- /dev/null
+++ b/freemocap-ui-old/electron-old/main/api.ts
@@ -0,0 +1,353 @@
+import { initTRPC } from '@trpc/server';
+import { z } from 'zod';
+import superjson from 'superjson';
+
+// Services
+import { PythonServer } from './services/python-server';
+import { SystemScanner } from './services/system-scanner';
+import { DependencyManager } from './services/dependency-manager';
+import { AppSettings } from './services/app-settings';
+import { dialog, shell, app } from 'electron';
+import path from 'node:path';
+import fs from 'node:fs';
+import { APP_PATHS } from './app-paths';
+
+// Initialize tRPC
+const t = initTRPC.create({
+ transformer: superjson,
+});
+
+// Helper function to check if a directory contains video files
+function hasVideoFiles(dirPath: string): boolean {
+ if (!fs.existsSync(dirPath)) {
+ return false;
+ }
+
+ try {
+ const entries = fs.readdirSync(dirPath);
+ const videoExtensions = ['.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv', '.webm'];
+
+ return entries.some(entry => {
+ const fullPath = path.join(dirPath, entry);
+ const stats = fs.statSync(fullPath);
+
+ if (stats.isFile()) {
+ const ext = path.extname(entry).toLowerCase();
+ return videoExtensions.includes(ext);
+ }
+ return false;
+ });
+ } catch (error) {
+ console.error('Error checking for video files:', error);
+ return false;
+ }
+}
+
+// Helper function to find camera calibration TOML file
+function findCameraCalibrationToml(dirPath: string): string | null {
+ if (!fs.existsSync(dirPath)) {
+ return null;
+ }
+
+ try {
+ const entries = fs.readdirSync(dirPath);
+
+ const calibrationFile = entries.find(entry => {
+ const fullPath = path.join(dirPath, entry);
+ const stats = fs.statSync(fullPath);
+
+ return stats.isFile() &&
+ entry.endsWith('_camera_calibration.toml');
+ });
+
+ return calibrationFile ? path.join(dirPath, calibrationFile) : null;
+ } catch (error) {
+ console.error('Error finding calibration TOML:', error);
+ return null;
+ }
+}
+
+// Create the main API router
+export const api = t.router({
+ // Python Server Management
+ pythonServer: t.router({
+ start: t.procedure
+ .input(z.object({ exePath: z.string().nullable() }))
+ .mutation(({ input }) => PythonServer.start(input.exePath)),
+
+ stop: t.procedure
+ .mutation(() => PythonServer.shutdown()),
+
+ getExecutablePath: t.procedure
+ .query(() => PythonServer.getCurrentExecutablePath()),
+
+ getExecutableCandidates: t.procedure
+ .query(() => PythonServer.validateAllCandidates()),
+
+ refreshCandidates: t.procedure
+ .mutation(() => PythonServer.refreshCandidates()),
+
+ isRunning: t.procedure
+ .query(() => PythonServer.isRunning()),
+
+ getProcessInfo: t.procedure
+ .query(() => PythonServer.getProcessInfo()),
+
+ getPort: t.procedure
+ .query(() => PythonServer.getPort()),
+ }),
+
+ // System Scanner
+ system: t.router({
+ scan: t.procedure
+ .query(() => SystemScanner.scan()),
+ }),
+
+ // Dependency Management
+ dependencies: t.router({
+ detectAll: t.procedure
+ .query(() => DependencyManager.detectAll()),
+
+ detect: t.procedure
+ .input(z.object({ dependencyId: z.string() }))
+ .query(({ input }) => DependencyManager.detect(input.dependencyId)),
+
+ install: t.procedure
+ .input(z.object({ dependencyId: z.string() }))
+ .mutation(({ input }) => DependencyManager.install(input.dependencyId)),
+ }),
+
+ // Persistent Settings (file-backed at ~/.freemocap/settings.json)
+ settings: t.router({
+ get: t.procedure
+ .input(z.object({ key: z.string() }))
+ .query(({ input }) => AppSettings.get(input.key)),
+
+ set: t.procedure
+ .input(z.object({ key: z.string(), value: z.unknown() }))
+ .mutation(({ input }) => {
+ AppSettings.set(input.key, input.value);
+ }),
+
+ delete: t.procedure
+ .input(z.object({ key: z.string() }))
+ .mutation(({ input }) => {
+ AppSettings.delete(input.key);
+ }),
+
+ getAll: t.procedure
+ .query(() => AppSettings.getAll()),
+
+ getConfigDir: t.procedure
+ .query(() => AppSettings.getConfigDir()),
+ }),
+
+ // File System Operations
+ fileSystem: t.router({
+ selectDirectory: t.procedure
+ .mutation(async () => {
+ const result = await dialog.showOpenDialog({
+ properties: ['openDirectory'],
+ });
+ return result.canceled ? null : result.filePaths[0];
+ }),
+
+ openFolder: t.procedure
+ .input(z.object({ path: z.string() }))
+ .mutation(async ({ input }) => {
+ await shell.openPath(input.path);
+ return true;
+ }),
+
+ getHomeDirectory: t.procedure
+ .query(() => app.getPath('home')),
+
+ getFolderContents: t.procedure
+ .input(z.object({ path: z.string() }))
+ .query(({ input }) => {
+ if (!fs.existsSync(input.path)) {
+ throw new Error('Folder does not exist');
+ }
+
+ const entries = fs.readdirSync(input.path);
+ return entries.map(entry => {
+ const fullPath = path.join(input.path, entry);
+ const stats = fs.statSync(fullPath);
+ return {
+ name: entry,
+ path: fullPath,
+ isDirectory: stats.isDirectory(),
+ isFile: stats.isFile(),
+ size: stats.size,
+ modified: stats.mtime,
+ };
+ });
+ }),
+
+ selectExecutableFile: t.procedure
+ .mutation(async () => {
+ const result = await dialog.showOpenDialog({
+ properties: ['openFile'],
+ filters: [
+ { name: 'Executable Files', extensions: ['exe'] },
+ { name: 'All Files', extensions: ['*'] },
+ ],
+ });
+ return result.canceled ? null : result.filePaths[0];
+ }),
+
+ validateCalibrationDirectory: t.procedure
+ .input(z.object({ directoryPath: z.string() }))
+ .query(({ input }) => {
+ const result = {
+ exists: false,
+ canRecord: false,
+ canCalibrate: false,
+ cameraCalibrationTomlPath: null as string | null,
+ hasSynchronizedVideos: false,
+ hasVideos: false,
+ errorMessage: null as string | null,
+ };
+
+ try {
+ result.exists = fs.existsSync(input.directoryPath);
+
+ if (!result.exists) {
+ result.canRecord = true;
+ result.canCalibrate = false;
+ return result;
+ }
+
+ const stats = fs.statSync(input.directoryPath);
+
+ if (!stats.isDirectory()) {
+ result.errorMessage = 'Path exists but is not a directory';
+ return result;
+ }
+
+ const synchronizedVideosPath = path.join(input.directoryPath, 'synchronized_videos');
+ result.hasSynchronizedVideos = fs.existsSync(synchronizedVideosPath) &&
+ fs.statSync(synchronizedVideosPath).isDirectory();
+
+ if (result.hasSynchronizedVideos) {
+ result.hasVideos = hasVideoFiles(synchronizedVideosPath);
+ }
+
+ if (!result.hasVideos) {
+ result.hasVideos = hasVideoFiles(input.directoryPath);
+ }
+
+ const entries = fs.readdirSync(input.directoryPath);
+ result.canRecord = entries.length === 0 || !result.hasVideos;
+
+ result.canCalibrate = result.hasVideos;
+
+ result.cameraCalibrationTomlPath = findCameraCalibrationToml(input.directoryPath);
+
+ return result;
+
+ } catch (error) {
+ console.error('Error validating calibration directory:', error);
+ result.errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+ return result;
+ }
+ }),
+
+ validateMocapDirectory: t.procedure
+ .input(z.object({ directoryPath: z.string() }))
+ .query(({ input }) => {
+ const result = {
+ exists: false,
+ canRecord: false,
+ canProcess: false,
+ cameraCalibrationTomlPath: null as string | null,
+ hasSynchronizedVideos: false,
+ hasVideos: false,
+ errorMessage: null as string | null,
+ };
+
+ try {
+ result.exists = fs.existsSync(input.directoryPath);
+
+ if (!result.exists) {
+ result.canRecord = true;
+ result.canProcess = false;
+ return result;
+ }
+
+ const stats = fs.statSync(input.directoryPath);
+
+ if (!stats.isDirectory()) {
+ result.errorMessage = 'Path exists but is not a directory';
+ return result;
+ }
+
+ const synchronizedVideosPath = path.join(input.directoryPath, 'synchronized_videos');
+ result.hasSynchronizedVideos = fs.existsSync(synchronizedVideosPath) &&
+ fs.statSync(synchronizedVideosPath).isDirectory();
+
+ if (result.hasSynchronizedVideos) {
+ result.hasVideos = hasVideoFiles(synchronizedVideosPath);
+ }
+
+ if (!result.hasVideos) {
+ result.hasVideos = hasVideoFiles(input.directoryPath);
+ }
+
+ const entries = fs.readdirSync(input.directoryPath);
+ result.canRecord = !result.hasVideos;
+ result.cameraCalibrationTomlPath = findCameraCalibrationToml(input.directoryPath);
+
+ result.canProcess = result.hasVideos && result.cameraCalibrationTomlPath !== null;
+
+ return result;
+
+ } catch (error) {
+ console.error('Error validating calibration directory:', error);
+ result.errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+ return result;
+ }
+ }),
+ }),
+
+ // Asset Management
+ assets: t.router({
+ getLogoBase64: t.procedure
+ .query((): string | null => {
+ try {
+ let logoPath: string | null = null;
+
+ if (fs.existsSync(APP_PATHS.FREEMOCAP_LOGO_PNG_SHARED_PATH)) {
+ logoPath = APP_PATHS.FREEMOCAP_LOGO_PNG_SHARED_PATH;
+ } else if (fs.existsSync(APP_PATHS.FREEMOCAP_LOGO_PNG_RESOURCES_PATH)) {
+ logoPath = APP_PATHS.FREEMOCAP_LOGO_PNG_RESOURCES_PATH;
+ }
+
+ if (!logoPath) {
+ console.error('Logo file not found in any expected location');
+ return null;
+ }
+
+ const imageBuffer = fs.readFileSync(logoPath);
+ const base64String = imageBuffer.toString('base64');
+ const mimeType = 'image/png';
+
+ return `data:${mimeType};base64,${base64String}`;
+ } catch (error) {
+ console.error('Failed to load logo as base64:', error);
+ return null;
+ }
+ }),
+
+ getLogoPngPath: t.procedure
+ .query(() => {
+ if (fs.existsSync(APP_PATHS.FREEMOCAP_LOGO_PNG_SHARED_PATH)) {
+ return APP_PATHS.FREEMOCAP_LOGO_PNG_SHARED_PATH;
+ }
+ return APP_PATHS.FREEMOCAP_LOGO_PNG_RESOURCES_PATH;
+ }),
+ }),
+});
+
+// Export the type for use in renderer
+export type AppAPI = typeof api;
\ No newline at end of file
diff --git a/freemocap-ui-old/electron-old/main/app-paths.ts b/freemocap-ui-old/electron-old/main/app-paths.ts
new file mode 100644
index 00000000..c1224e95
--- /dev/null
+++ b/freemocap-ui-old/electron-old/main/app-paths.ts
@@ -0,0 +1,63 @@
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+import {app} from "electron";
+
+export const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+
+// Function to get the correct resources path based on environment
+const getResourcesPath = () => {
+ if (app.isPackaged) {
+ const resourcesPath = path.join(process.resourcesPath, "app.asar.unpacked")
+ console.log(`App is packaged. resourcesPath: ${resourcesPath}`);
+ return resourcesPath;
+ } else {
+ const resourcesPath = path.join(__dirname, "../../");
+ console.log(`App is in development. resourcesPath: ${resourcesPath}`);
+ return resourcesPath;
+ }
+
+};
+
+// Python server executable candidates in order of preference
+export const PYTHON_EXECUTABLE_CANDIDATES = [
+ {
+ name: 'development',
+ path: path.join(getResourcesPath(), '../dist/freemocap_server.exe'),
+ description: 'Development build executable'
+ },
+ {
+ name: 'installed',
+ path: path.join(getResourcesPath(), 'freemocap_server.exe'),
+ description: 'Executable in the installation folder'
+ },
+
+ {
+ name: 'portable',
+ path: path.join(process.cwd(), 'freemocap_server.exe'),
+ description: 'Portable executable in current directory'
+ },
+ {
+ name: 'system-path',
+ path: 'freemocap_server.exe', // Will be found via PATH
+ description: 'Executable available in system PATH'
+ }
+];
+
+export const APP_PATHS = {
+ PRELOAD: path.join(__dirname, "../preload/index.mjs"),
+ RENDERER_HTML: path.join(__dirname, "../../dist/index.html"),
+ FREEMOCAP_ICON_PATH: path.resolve(
+ __dirname,
+ "../../../shared/logo/freemocap-logo.ico"
+ ),
+ FREEMOCAP_LOGO_PNG_RESOURCES_PATH: path.join(getResourcesPath(), 'dist/freemocap-logo.png'),
+ FREEMOCAP_LOGO_PNG_SHARED_PATH:path.resolve(
+ __dirname,
+ "../../../shared/logo/freemocap-logo.png"
+ ),
+
+};
+
+
+console.log(`APP_PATHS: ${JSON.stringify(APP_PATHS, null, 2)}`);
diff --git a/freemocap-ui-old/electron-old/main/index.ts b/freemocap-ui-old/electron-old/main/index.ts
new file mode 100644
index 00000000..e6224780
--- /dev/null
+++ b/freemocap-ui-old/electron-old/main/index.ts
@@ -0,0 +1,59 @@
+import { app, BrowserWindow } from 'electron';
+import { setupIPC } from './ipc';
+import { WindowManager } from './services/window-manager';
+import { PythonServer } from './services/python-server';
+import { buildAppMenu } from './services/app-menu';
+import { LifecycleLogger } from './services/logger';
+
+export const APP_ENVIRONMENT = {
+ IS_DEV: process.env.NODE_ENV === 'development',
+ VITE_DEV_SERVER_URL: process.env.VITE_DEV_SERVER_URL,
+};
+
+if (process.platform === 'win32') app.setAppUserModelId(app.getName());
+
+const gotTheLock = app.requestSingleInstanceLock();
+
+if (!gotTheLock) {
+ app.quit();
+} else {
+ app.on('second-instance', () => {
+ const windows = BrowserWindow.getAllWindows();
+ if (windows.length > 0) {
+ const window = windows[0];
+ if (window.isMinimized()) window.restore();
+ window.focus();
+ }
+ });
+
+ app.whenReady().then(async () => {
+ LifecycleLogger.logProcessInfo();
+ console.log('App is ready');
+
+ setupIPC();
+
+ const mainWindow = WindowManager.createMainWindow();
+
+ // Set up the native application menu (File, Edit, View, Tools, etc.)
+ buildAppMenu(mainWindow);
+ });
+
+ app.on('window-all-closed', async () => {
+ console.log('All windows closed, shutting down...');
+ await PythonServer.shutdown();
+ app.quit();
+ });
+
+ app.on('activate', () => {
+ if (BrowserWindow.getAllWindows().length === 0) {
+ WindowManager.createMainWindow();
+ }
+ });
+
+ app.on('before-quit', async (event) => {
+ event.preventDefault();
+ console.log('App is quitting, cleaning up...');
+ await PythonServer.shutdown();
+ app.exit(0);
+ });
+}
diff --git a/freemocap-ui-old/electron-old/main/ipc.ts b/freemocap-ui-old/electron-old/main/ipc.ts
new file mode 100644
index 00000000..cf09c44f
--- /dev/null
+++ b/freemocap-ui-old/electron-old/main/ipc.ts
@@ -0,0 +1,35 @@
+// electron/main/ipc.ts
+import { ipcMain } from 'electron';
+import { api } from './api';
+import superjson from 'superjson';
+
+export function setupIPC(): void {
+ ipcMain.handle('trpc', async (_event, { path, input }) => {
+ try {
+ const caller = api.createCaller({});
+
+ const pathParts = path.split('.');
+ let current: any = caller;
+
+ for (let i = 0; i < pathParts.length - 1; i++) {
+ current = current[pathParts[i]];
+ if (!current) {
+ throw new Error(`Router not found: ${pathParts.slice(0, i + 1).join('.')}`);
+ }
+ }
+
+ const procedureName = pathParts[pathParts.length - 1];
+ const fn = current[procedureName];
+
+ if (typeof fn !== 'function') {
+ throw new Error(`Procedure not found: ${path}`);
+ }
+
+ const result = await fn(input);
+ return superjson.serialize(result);
+ } catch (error) {
+ console.error(`IPC Error for ${path}:`, error);
+ throw error;
+ }
+ });
+}
diff --git a/freemocap-ui-old/electron-old/main/services/app-menu.ts b/freemocap-ui-old/electron-old/main/services/app-menu.ts
new file mode 100644
index 00000000..15d215ab
--- /dev/null
+++ b/freemocap-ui-old/electron-old/main/services/app-menu.ts
@@ -0,0 +1,144 @@
+import { Menu, BrowserWindow, shell, app } from 'electron';
+import path from 'node:path';
+import os from 'node:os';
+
+/**
+ * Build and set the native application menu.
+ * Call this once after the main window is created.
+ */
+export function buildAppMenu(mainWindow: BrowserWindow): void {
+ const isMac = process.platform === 'darwin';
+
+ const template: Electron.MenuItemConstructorOptions[] = [
+ // macOS app menu
+ ...(isMac ? [{
+ label: app.name,
+ submenu: [
+ { role: 'about' as const },
+ { type: 'separator' as const },
+ {
+ label: 'Settings…',
+ click: () => sendNavigate(mainWindow, '/settings'),
+ },
+ { type: 'separator' as const },
+ { role: 'services' as const },
+ { type: 'separator' as const },
+ { role: 'hide' as const },
+ { role: 'hideOthers' as const },
+ { role: 'unhide' as const },
+ { type: 'separator' as const },
+ { role: 'quit' as const },
+ ],
+ }] : []),
+
+ // File
+ {
+ label: 'File',
+ submenu: [
+ isMac ? { role: 'close' as const } : { role: 'quit' as const },
+ ],
+ },
+
+ // Edit
+ {
+ label: 'Edit',
+ submenu: [
+ { role: 'undo' as const },
+ { role: 'redo' as const },
+ { type: 'separator' as const },
+ { role: 'cut' as const },
+ { role: 'copy' as const },
+ { role: 'paste' as const },
+ { role: 'selectAll' as const },
+ ],
+ },
+
+ // View
+ {
+ label: 'View',
+ submenu: [
+ { role: 'reload' as const },
+ { role: 'forceReload' as const },
+ { role: 'toggleDevTools' as const },
+ { type: 'separator' as const },
+ { role: 'resetZoom' as const },
+ { role: 'zoomIn' as const },
+ { role: 'zoomOut' as const },
+ { type: 'separator' as const },
+ { role: 'togglefullscreen' as const },
+ ],
+ },
+
+ // Tools
+ {
+ label: 'Tools',
+ submenu: [
+ {
+ label: 'Settings…',
+ accelerator: isMac ? 'Cmd+Shift+S' : 'Ctrl+Shift+S',
+ click: () => sendNavigate(mainWindow, '/settings'),
+ },
+ { type: 'separator' as const },
+ {
+ label: 'Open Config Folder',
+ click: () => {
+ const configDir = path.join(os.homedir(), '.freemocap');
+ shell.openPath(configDir);
+ },
+ },
+ {
+ label: 'Open Data Folder',
+ click: () => {
+ const dataDir = path.join(os.homedir(), 'freemocap_data');
+ shell.openPath(dataDir);
+ },
+ },
+ ],
+ },
+
+ // Window
+ {
+ label: 'Window',
+ submenu: [
+ { role: 'minimize' as const },
+ { role: 'zoom' as const },
+ ...(isMac ? [
+ { type: 'separator' as const },
+ { role: 'front' as const },
+ ] : [
+ { role: 'close' as const },
+ ]),
+ ],
+ },
+
+ // Help
+ {
+ label: 'Help',
+ submenu: [
+ {
+ label: 'FreeMoCap Documentation',
+ click: () => shell.openExternal('https://freemocap.github.io/documentation/'),
+ },
+ {
+ label: 'GitHub Repository',
+ click: () => shell.openExternal('https://github.com/freemocap/freemocap'),
+ },
+ { type: 'separator' as const },
+ {
+ label: 'Settings…',
+ click: () => sendNavigate(mainWindow, '/settings'),
+ },
+ ],
+ },
+ ];
+
+ const menu = Menu.buildFromTemplate(template);
+ Menu.setApplicationMenu(menu);
+}
+
+/** Send a navigation request to the renderer process. */
+function sendNavigate(window: BrowserWindow, route: string): void {
+ if (window.isDestroyed()) return;
+ window.webContents.send('navigate', route);
+ window.focus();
+}
\ No newline at end of file
diff --git a/freemocap-ui-old/electron-old/main/services/app-settings.ts b/freemocap-ui-old/electron-old/main/services/app-settings.ts
new file mode 100644
index 00000000..ac3ce52a
--- /dev/null
+++ b/freemocap-ui-old/electron-old/main/services/app-settings.ts
@@ -0,0 +1,81 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const FREEMOCAP_CONFIG_DIR = path.join(os.homedir(), '.freemocap');
+const SETTINGS_FILE = path.join(FREEMOCAP_CONFIG_DIR, 'settings.json');
+
+type SettingsData = Record<string, unknown>;
+
+function ensureConfigDir(): void {
+ if (!fs.existsSync(FREEMOCAP_CONFIG_DIR)) {
+ fs.mkdirSync(FREEMOCAP_CONFIG_DIR, { recursive: true });
+ }
+}
+
+function readAll(): SettingsData {
+ ensureConfigDir();
+ if (!fs.existsSync(SETTINGS_FILE)) {
+ return {};
+ }
+ const raw = fs.readFileSync(SETTINGS_FILE, 'utf-8');
+ const parsed: unknown = JSON.parse(raw);
+ if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+ throw new Error(`Corrupted settings file: expected object, got ${typeof parsed}`);
+ }
+ return parsed as SettingsData;
+}
+
+function writeAll(data: SettingsData): void {
+ ensureConfigDir();
+ fs.writeFileSync(SETTINGS_FILE, JSON.stringify(data, null, 2), 'utf-8');
+}
+
+export class AppSettings {
+ /** Get a single value by key. Returns null if the key doesn't exist. */
+ static get(key: string): unknown {
+ const data = readAll();
+ if (!(key in data)) {
+ return null;
+ }
+ return data[key];
+ }
+
+ /** Set a single key-value pair. */
+ static set(key: string, value: unknown): void {
+ const data = readAll();
+ data[key] = value;
+ writeAll(data);
+ }
+
+ /** Delete a single key. */
+ static delete(key: string): void {
+ const data = readAll();
+ if (!(key in data)) {
+ return;
+ }
+ delete data[key];
+ writeAll(data);
+ }
+
+ /** Get all settings as a plain object. */
+ static getAll(): SettingsData {
+ return readAll();
+ }
+
+ /** Replace all settings with the given object. */
+ static setAll(data: SettingsData): void {
+ writeAll(data);
+ }
+
+ /** Get the path to the config directory (~/.freemocap/). */
+ static getConfigDir(): string {
+ ensureConfigDir();
+ return FREEMOCAP_CONFIG_DIR;
+ }
+
+ /** Get the path to the settings file. */
+ static getSettingsFilePath(): string {
+ return SETTINGS_FILE;
+ }
+}
diff --git a/freemocap-ui-old/electron-old/main/services/dependency-manager.ts b/freemocap-ui-old/electron-old/main/services/dependency-manager.ts
new file mode 100644
index 00000000..c4aab5f1
--- /dev/null
+++ b/freemocap-ui-old/electron-old/main/services/dependency-manager.ts
@@ -0,0 +1,372 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const execAsync = promisify(exec);
+
+// ── Types ──
+
+export type DependencyStatus = 'installed' | 'missing' | 'outdated' | 'checking' | 'installing' | 'error';
+
+export interface DependencyInfo {
+ id: string;
+ name: string;
+ description: string;
+ required: boolean;
+ status: DependencyStatus;
+ version: string | null;
+ installedPath: string | null;
+ error: string | null;
+}
+
+// ── Constants ──
+
+const UV_INSTALL_URL_WINDOWS = 'https://astral.sh/uv/install.ps1';
+const UV_INSTALL_URL_UNIX = 'https://astral.sh/uv/install.sh';
+
+// ── Helpers ──
+
+async function commandExists(command: string): Promise<{ exists: boolean; output: string }> {
+ try {
+ const { stdout } = await execAsync(
+ process.platform === 'win32'
+ ? `where ${command}`
+ : `which ${command}`,
+ { timeout: 10000 },
+ );
+ return { exists: true, output: stdout.trim() };
+ } catch {
+ return { exists: false, output: '' };
+ }
+}
+
+async function getCommandVersion(command: string, versionFlag: string = '--version'): Promise<string | null> {
+ try {
+ const { stdout } = await execAsync(`${command} ${versionFlag}`, { timeout: 15000 });
+ return stdout.trim().split('\n')[0];
+ } catch {
+ return null;
+ }
+}
+
+// ── Blender Detection ──
+
+async function detectBlender(): Promise<DependencyInfo> {
+ const info: DependencyInfo = {
+ id: 'blender',
+ name: 'Blender',
+ description: '3D creation suite β€” used for viewing and animating motion capture data.',
+ required: false,
+ status: 'checking',
+ version: null,
+ installedPath: null,
+ error: null,
+ };
+
+ // Check PATH
+ const { exists, output } = await commandExists('blender');
+ if (exists) {
+ info.installedPath = output.split('\n')[0].trim();
+ info.version = await getCommandVersion('blender');
+ info.status = 'installed';
+ return info;
+ }
+
+ // Check common install locations
+ const candidates: string[] = [];
+ switch (process.platform) {
+ case 'win32':
+ // Common Windows paths
+ const programFiles = process.env['ProgramFiles'] || 'C:\\Program Files';
+ try {
+ const blenderDir = path.join(programFiles, 'Blender Foundation');
+ if (fs.existsSync(blenderDir)) {
+ const versions = fs.readdirSync(blenderDir).sort().reverse();
+ for (const ver of versions) {
+ candidates.push(path.join(blenderDir, ver, 'blender.exe'));
+ }
+ }
+ } catch { /* dir doesn't exist */ }
+ break;
+ case 'darwin':
+ candidates.push('/Applications/Blender.app/Contents/MacOS/Blender');
+ candidates.push('/Applications/Blender.app/Contents/MacOS/blender');
+ break;
+ case 'linux':
+ candidates.push('/usr/bin/blender');
+ candidates.push('/snap/bin/blender');
+ candidates.push('/var/lib/flatpak/exports/bin/org.blender.Blender');
+ break;
+ }
+
+ for (const candidate of candidates) {
+ if (fs.existsSync(candidate)) {
+ info.installedPath = candidate;
+ try {
+ const { stdout } = await execAsync(`"${candidate}" --version`, { timeout: 15000 });
+ info.version = stdout.trim().split('\n')[0];
+ } catch { /* version check failed but binary exists */ }
+ info.status = 'installed';
+ return info;
+ }
+ }
+
+ info.status = 'missing';
+ return info;
+}
+
+// ── uv Detection ──
+
+async function detectUv(): Promise<DependencyInfo> {
+ const info: DependencyInfo = {
+ id: 'uv',
+ name: 'uv',
+ description: 'Fast Python package manager β€” useful for development and managing additional processing tools.',
+ required: false,
+ status: 'checking',
+ version: null,
+ installedPath: null,
+ error: null,
+ };
+
+ const { exists, output } = await commandExists('uv');
+ if (exists) {
+ info.installedPath = output.split('\n')[0].trim();
+ info.version = await getCommandVersion('uv');
+ info.status = 'installed';
+ return info;
+ }
+
+ // Check common uv install locations
+ const home = os.homedir();
+ const candidates: string[] = [];
+ switch (process.platform) {
+ case 'win32':
+ candidates.push(path.join(home, '.local', 'bin', 'uv.exe'));
+ candidates.push(path.join(home, '.cargo', 'bin', 'uv.exe'));
+ break;
+ case 'darwin':
+ case 'linux':
+ candidates.push(path.join(home, '.local', 'bin', 'uv'));
+ candidates.push(path.join(home, '.cargo', 'bin', 'uv'));
+ break;
+ }
+
+ for (const candidate of candidates) {
+ if (fs.existsSync(candidate)) {
+ info.installedPath = candidate;
+ try {
+ const { stdout } = await execAsync(`"${candidate}" --version`, { timeout: 10000 });
+ info.version = stdout.trim();
+ } catch { /* binary found but version check failed */ }
+ info.status = 'installed';
+ return info;
+ }
+ }
+
+ info.status = 'missing';
+ return info;
+}
+
+// ── FreeMoCap Server Executable Detection ──
+
+async function detectFreemocapServer(): Promise<DependencyInfo> {
+ const info: DependencyInfo = {
+ id: 'freemocap-server',
+ name: 'FreeMoCap Server',
+ description: 'Bundled Python server that handles cameras, processing, and WebSocket communication.',
+ required: true,
+ status: 'checking',
+ version: null,
+ installedPath: null,
+ error: null,
+ };
+
+ // Use the PythonServer candidate validation to find the exe
+ try {
+ const { PythonServer } = await import('./python-server');
+ const candidates = await PythonServer.validateAllCandidates();
+ const validCandidate = candidates.find(c => c.isValid);
+
+ if (validCandidate) {
+ info.status = 'installed';
+ info.installedPath = validCandidate.path;
+ info.version = validCandidate.name;
+ } else {
+ info.status = 'missing';
+ info.error = 'No valid freemocap_server executable found. Reinstall the application or build the server.';
+ }
+ } catch (err) {
+ info.status = 'error';
+ info.error = `Detection failed: ${err instanceof Error ? err.message : String(err)}`;
+ }
+
+ return info;
+}
+
+// ── CUDA Detection ──
+
+async function detectCuda(): Promise<DependencyInfo> {
+ const info: DependencyInfo = {
+ id: 'cuda',
+ name: 'NVIDIA CUDA',
+ description: 'GPU acceleration for pose estimation β€” dramatically speeds up processing.',
+ required: false,
+ status: 'checking',
+ version: null,
+ installedPath: null,
+ error: null,
+ };
+
+ try {
+ const { stdout } = await execAsync('nvidia-smi', { timeout: 10000 });
+ // Parse CUDA version from nvidia-smi output
+ const cudaMatch = stdout.match(/CUDA Version:\s*([\d.]+)/);
+ if (cudaMatch) {
+ info.version = `CUDA ${cudaMatch[1]}`;
+ info.status = 'installed';
+ } else {
+ // nvidia-smi works but CUDA version not found β€” driver exists, CUDA toolkit may not
+ const driverMatch = stdout.match(/Driver Version:\s*([\d.]+)/);
+ info.version = driverMatch ? `Driver ${driverMatch[1]}` : 'Driver detected';
+ info.status = 'installed';
+ }
+ } catch {
+ info.status = 'missing';
+ }
+
+ return info;
+}
+
+// ── Installation ──
+
+async function installBlender(): Promise<void> {
+ switch (process.platform) {
+ case 'win32': {
+ // Try winget first
+ const { exists: hasWinget } = await commandExists('winget');
+ if (hasWinget) {
+ const { stderr } = await execAsync(
+ 'winget install BlenderFoundation.Blender --silent --accept-package-agreements --accept-source-agreements',
+ { timeout: 600000 }, // 10 min timeout
+ );
+ if (stderr && stderr.includes('error')) {
+ throw new Error(`winget install failed: ${stderr}`);
+ }
+ return;
+ }
+ throw new Error(
+ 'winget is not available. Please install Blender manually from https://www.blender.org/download/',
+ );
+ }
+ case 'darwin': {
+ const { exists: hasBrew } = await commandExists('brew');
+ if (hasBrew) {
+ await execAsync('brew install --cask blender', { timeout: 600000 });
+ return;
+ }
+ throw new Error(
+ 'Homebrew is not available. Please install Blender manually from https://www.blender.org/download/',
+ );
+ }
+ case 'linux': {
+ // Try flatpak, then snap
+ const { exists: hasFlatpak } = await commandExists('flatpak');
+ if (hasFlatpak) {
+ await execAsync(
+ 'flatpak install -y flathub org.blender.Blender',
+ { timeout: 600000 },
+ );
+ return;
+ }
+ const { exists: hasSnap } = await commandExists('snap');
+ if (hasSnap) {
+ await execAsync('sudo snap install blender --classic', { timeout: 600000 });
+ return;
+ }
+ throw new Error(
+ 'Neither flatpak nor snap is available. Please install Blender using your package manager.',
+ );
+ }
+ default:
+ throw new Error(`Unsupported platform: ${process.platform}`);
+ }
+}
+
+async function installUv(): Promise<void> {
+ switch (process.platform) {
+ case 'win32':
+ await execAsync(
+ `powershell -ExecutionPolicy ByPass -c "irm ${UV_INSTALL_URL_WINDOWS} | iex"`,
+ { timeout: 120000 },
+ );
+ break;
+ case 'darwin':
+ case 'linux':
+ await execAsync(
+ `curl -LsSf ${UV_INSTALL_URL_UNIX} | sh`,
+ { timeout: 120000 },
+ );
+ break;
+ default:
+ throw new Error(`Unsupported platform: ${process.platform}`);
+ }
+}
+
+// ── Public API ──
+
+export class DependencyManager {
+ static async detectAll(): Promise<DependencyInfo[]> {
+ const results = await Promise.all([
+ detectFreemocapServer(),
+ detectUv(),
+ detectCuda(),
+ detectBlender(),
+ ]);
+ return results;
+ }
+
+ static async detect(dependencyId: string): Promise<DependencyInfo> {
+ switch (dependencyId) {
+ case 'freemocap-server':
+ return detectFreemocapServer();
+ case 'uv':
+ return detectUv();
+ case 'blender':
+ return detectBlender();
+ case 'cuda':
+ return detectCuda();
+ default:
+ throw new Error(`Unknown dependency: ${dependencyId}`);
+ }
+ }
+
+ static async install(dependencyId: string): Promise<DependencyInfo> {
+ switch (dependencyId) {
+ case 'blender':
+ await installBlender();
+ return detectBlender();
+
+ case 'uv':
+ await installUv();
+ return detectUv();
+
+ case 'freemocap-server':
+ throw new Error(
+ 'The FreeMoCap server executable is bundled with the application. ' +
+ 'Reinstall the app to restore it.',
+ );
+
+ case 'cuda':
+ throw new Error(
+ 'CUDA cannot be installed automatically. ' +
+ 'Please install the NVIDIA CUDA Toolkit from https://developer.nvidia.com/cuda-downloads',
+ );
+
+ default:
+ throw new Error(`Unknown dependency: ${dependencyId}`);
+ }
+ }
+}
\ No newline at end of file
diff --git a/freemocap-ui-old/electron-old/main/services/logger.ts b/freemocap-ui-old/electron-old/main/services/logger.ts
new file mode 100644
index 00000000..deb6a09f
--- /dev/null
+++ b/freemocap-ui-old/electron-old/main/services/logger.ts
@@ -0,0 +1,23 @@
+import { app, BrowserWindow } from 'electron';
+import { exec } from 'child_process';
+
+export class LifecycleLogger {
+ static logProcessInfo() {
+ console.log(`
+ ============================================
+ Starting FreeMoCap v${app.getVersion()}
+ Platform: ${process.platform}-${process.arch}
+ Node: ${process.versions.node}
+ Chrome: ${process.versions.chrome}
+ Electron: ${process.versions.electron}
+ ============================================`);
+ }
+
+ static logWindowCreation(win: BrowserWindow) {
+ console.log(`[Window Manager] Created window ID: ${win.id}`);
+ }
+
+ static logPythonProcess(pythonProcess: ReturnType<typeof exec>) {
+ console.log(`[Python Server] Started process PID: ${pythonProcess.pid}`);
+ }
+}
diff --git a/freemocap-ui-old/electron-old/main/services/python-server.ts b/freemocap-ui-old/electron-old/main/services/python-server.ts
new file mode 100644
index 00000000..941730c9
--- /dev/null
+++ b/freemocap-ui-old/electron-old/main/services/python-server.ts
@@ -0,0 +1,294 @@
+import {exec} from 'child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import {LifecycleLogger} from "./logger";
+import {promisify} from 'util';
+import treeKill from "tree-kill";
+import {PYTHON_EXECUTABLE_CANDIDATES} from "../app-paths";
+
+const treeKillAsync = promisify(treeKill);
+let pythonProcess: ReturnType<typeof exec> | null = null;
+
+const PORT_SENTINEL = "FREEMOCAP_PORT";
+const DEFAULT_PORT = 53117;
+const PORT_DISCOVERY_TIMEOUT_MS = 30_000;
+
+export interface ExecutableCandidate {
+ name: string;
+ path: string;
+ description: string;
+ isValid?: boolean;
+ error?: string;
+ resolvedPath?: string;
+}
+
+export class PythonServer {
+ private static currentExecutablePath: string | null = null;
+ private static validatedCandidates: ExecutableCandidate[] = [];
+ private static discoveredPort: number | null = null;
+
+ /**
+ * Start the Python server and wait for it to report which port it bound to.
+ * Returns the actual port number.
+ */
+ static async start(exePath: string | null = null): Promise<number> {
+ console.log('Starting python server subprocess...');
+
+ try {
+ await this.shutdown();
+
+ let executablePath: string;
+
+ if (exePath) {
+ this.validateExecutable(exePath);
+ executablePath = exePath;
+ console.log(`Using provided executable path: ${executablePath}`);
+ } else {
+ executablePath = await this.findValidExecutablePath();
+ console.log(`Using auto-detected executable path: ${executablePath}`);
+ }
+
+ this.currentExecutablePath = executablePath;
+ this.discoveredPort = null;
+ console.log(`Launching Python server from: ${executablePath}`);
+ pythonProcess = exec(`"${executablePath}"`, {
+ env: {
+ ...process.env,
+ },
+ maxBuffer: 1024 * 1024 * 100 // 100MB buffer
+ });
+
+ pythonProcess.on('exit', (code) => {
+ console.log(`Python server exited (code: ${code})`);
+ this.currentExecutablePath = null;
+ });
+
+ pythonProcess.on('error', (error) => {
+ console.error('Python server process error:', error);
+ this.currentExecutablePath = null;
+ });
+
+ if (!pythonProcess.pid) {
+ throw new Error('Python server failed to start - no process ID');
+ }
+
+ LifecycleLogger.logPythonProcess(pythonProcess);
+ console.log(`βœ” Python server started successfully (PID: ${pythonProcess.pid})`);
+
+ const port = await this.waitForPort(pythonProcess);
+ this.discoveredPort = port;
+ console.log(`βœ” Python server bound to port ${port}`);
+
+ return port;
+
+ } catch (error) {
+ console.error('Failed to start Python server:', error);
+ this.currentExecutablePath = null;
+ throw error;
+ }
+ }
+
+ /**
+ * Read stdout line-by-line until we find the port sentinel or time out.
+ */
+ private static waitForPort(proc: ReturnType<typeof exec>): Promise<number> {
+ return new Promise((resolve, reject) => {
+ const timeout = setTimeout(() => {
+ reject(new Error(
+ `Python server did not report a port within ${PORT_DISCOVERY_TIMEOUT_MS}ms`
+ ));
+ }, PORT_DISCOVERY_TIMEOUT_MS);
+
+ const onData = (chunk: Buffer | string): void => {
+ const text = chunk.toString();
+ for (const line of text.split('\n')) {
+ const trimmed = line.trim();
+ if (trimmed.startsWith(`${PORT_SENTINEL}=`)) {
+ const portStr = trimmed.slice(PORT_SENTINEL.length + 1);
+ const port = parseInt(portStr, 10);
+ if (isNaN(port)) {
+ clearTimeout(timeout);
+ reject(new Error(`Invalid port in sentinel line: ${trimmed}`));
+ return;
+ }
+ clearTimeout(timeout);
+ proc.stdout?.off('data', onData);
+ resolve(port);
+ return;
+ }
+ }
+ };
+
+ if (!proc.stdout) {
+ clearTimeout(timeout);
+ reject(new Error('Python process has no stdout stream'));
+ return;
+ }
+
+ proc.stdout.on('data', onData);
+
+ proc.on('exit', (code) => {
+ clearTimeout(timeout);
+ reject(new Error(
+ `Python server exited with code ${code} before reporting a port`
+ ));
+ });
+ });
+ }
+
+ static async shutdown() {
+ if (!pythonProcess || !pythonProcess.pid) {
+ console.log('No Python server process to shutdown');
+ return;
+ }
+
+ console.log(`Shutting down Python server (PID: ${pythonProcess.pid})`);
+
+ try {
+ await treeKillAsync(pythonProcess.pid);
+ console.log('βœ” Python server process tree terminated');
+ } catch (error) {
+ console.error('Error killing process tree:', error);
+ try {
+ pythonProcess?.kill('SIGKILL');
+ console.log('βœ” Python server force-killed as fallback');
+ } catch (killError) {
+ console.error('Failed to force-kill Python server:', killError);
+ }
+ }
+
+ await new Promise(resolve => setTimeout(resolve, 1000));
+
+ if (pythonProcess && !pythonProcess.killed) {
+ console.warn('Python server may not have exited cleanly');
+ }
+
+ pythonProcess = null;
+ this.currentExecutablePath = null;
+ this.discoveredPort = null;
+ console.log('βœ” Python server shutdown complete');
+ }
+
+ /**
+ * Get the port the Python server is currently bound to, or the default if not yet started.
+ */
+ static getPort(): number {
+ return this.discoveredPort ?? DEFAULT_PORT;
+ }
+
+ static getCurrentExecutablePath(): string | null {
+ return this.currentExecutablePath;
+ }
+
+ static async findValidExecutablePath(): Promise<string> {
+ console.log('Searching for valid Python server executable...');
+
+ if (this.validatedCandidates.length === 0) {
+ await this.validateAllCandidates();
+ }
+
+ const validCandidate = this.validatedCandidates.find(candidate => candidate.isValid);
+
+ if (!validCandidate) {
+ const errorMessage = 'No valid Python server executable found in any candidate location:\n' +
+ this.validatedCandidates.map(c => ` - ${c.name}: ${c.error || 'Unknown error'}`).join('\n');
+ throw new Error(errorMessage);
+ }
+
+ console.log(`βœ” Selected executable: ${validCandidate.name} (${validCandidate.path})`);
+ return validCandidate.path;
+ }
+
+ static async validateAllCandidates(): Promise<ExecutableCandidate[]> {
+ console.log('Validating all executable candidates...');
+
+ const allValidatedCandidates = await Promise.all(
+ PYTHON_EXECUTABLE_CANDIDATES.map(async (candidate) => {
+ const validatedCandidate: ExecutableCandidate = {
+ ...candidate,
+ isValid: false
+ };
+
+ try {
+ this.validateExecutable(candidate.path);
+ validatedCandidate.isValid = true;
+ validatedCandidate.resolvedPath = fs.existsSync(candidate.path)
+ ? path.resolve(candidate.path)
+ : candidate.path;
+ console.log(` βœ” ${candidate.name}: Valid`);
+ } catch (error) {
+ validatedCandidate.error = error instanceof Error ? error.message : 'Unknown validation error';
+ console.log(` βœ— ${candidate.name}: ${validatedCandidate.error}`);
+ }
+
+ return validatedCandidate;
+ })
+ );
+
+ const seenPaths = new Set<string>();
+ this.validatedCandidates = allValidatedCandidates.filter(candidate => {
+ const pathKey = candidate.resolvedPath || candidate.path;
+
+ if (seenPaths.has(pathKey)) {
+ console.log(` ⚠ Skipping duplicate: ${candidate.name} (same as another candidate)`);
+ return false;
+ }
+
+ seenPaths.add(pathKey);
+ return true;
+ });
+
+ const validCount = this.validatedCandidates.filter(c => c.isValid).length;
+ console.log(`Validation complete: ${validCount}/${this.validatedCandidates.length} unique candidates are valid`);
+
+ return this.validatedCandidates;
+ }
+
+ static getPythonServerExecutableCandidates(): ExecutableCandidate[] {
+ return [...this.validatedCandidates];
+ }
+
+ static async refreshCandidates(): Promise<ExecutableCandidate[]> {
+ console.log('Refreshing executable candidates validation...');
+ this.validatedCandidates = [];
+ return await this.validateAllCandidates();
+ }
+
+ static isRunning(): boolean {
+ return pythonProcess !== null && pythonProcess.pid !== undefined && !pythonProcess.killed;
+ }
+
+ static getProcessInfo(): { pid: number | undefined; killed: boolean } | null {
+ if (!pythonProcess) return null;
+
+ return {
+ pid: pythonProcess.pid,
+ killed: pythonProcess.killed || false
+ };
+ }
+
+ private static validateExecutable(exePath: string): void {
+ if (!fs.existsSync(exePath)) {
+ throw new Error(`Executable not found at: ${exePath}`);
+ }
+
+ const stats = fs.statSync(exePath);
+ if (!stats.isFile()) {
+ throw new Error(`Path is not a file: ${exePath}`);
+ }
+
+ try {
+ fs.accessSync(exePath, fs.constants.F_OK | fs.constants.R_OK);
+
+ if (process.platform !== 'win32') {
+ fs.accessSync(exePath, fs.constants.X_OK);
+ }
+ } catch (error) {
+ throw new Error(`File is not accessible or executable: ${exePath}`);
+ }
+
+ if (process.platform === 'win32' && !exePath.toLowerCase().endsWith('.exe')) {
+ console.warn(`Warning: Executable doesn't have .exe extension: ${exePath}`);
+ }
+ }
+}
\ No newline at end of file
diff --git a/freemocap-ui-old/electron-old/main/services/system-scanner.ts b/freemocap-ui-old/electron-old/main/services/system-scanner.ts
new file mode 100644
index 00000000..f2c4b163
--- /dev/null
+++ b/freemocap-ui-old/electron-old/main/services/system-scanner.ts
@@ -0,0 +1,389 @@
+import os from 'node:os';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile, exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { app } from 'electron';
+
+const execFileAsync = promisify(execFile);
+const execAsync = promisify(exec);
+
+// ── Types ──
+
+export interface CpuInfo {
+ model: string;
+ cores: number;
+ threads: number;
+ speedMhz: number;
+}
+
+export interface RamInfo {
+ totalGb: number;
+ availableGb: number;
+}
+
+export interface GpuInfo {
+ name: string;
+ vendor: string;
+ vramMb: number | null;
+ cudaAvailable: boolean;
+ cudaVersion: string | null;
+}
+
+export interface DiskInfo {
+ /** The drive/mount where freemocap data lives */
+ path: string;
+ totalGb: number;
+ freeGb: number;
+}
+
+export interface OsInfo {
+ platform: string;
+ release: string;
+ arch: string;
+ hostname: string;
+}
+
+export type PerformanceTier = 'basic' | 'standard' | 'advanced' | 'pro';
+
+export interface PerformanceRecommendation {
+ tier: PerformanceTier;
+ label: string;
+ description: string;
+ maxCameras: number;
+ maxResolution: string;
+ realtimeTracking: boolean;
+ warnings: string[];
+}
+
+export interface SystemScanResult {
+ cpu: CpuInfo;
+ ram: RamInfo;
+ gpus: GpuInfo[];
+ disk: DiskInfo;
+ os: OsInfo;
+ recommendation: PerformanceRecommendation;
+ scannedAt: string;
+}
+
+// ── Scanners ──
+
+function scanCpu(): CpuInfo {
+ const cpus = os.cpus();
+ if (cpus.length === 0) {
+ throw new Error('Failed to detect CPU info');
+ }
+ return {
+ model: cpus[0].model.trim(),
+ cores: new Set(cpus.map((_, i) => Math.floor(i / 2))).size || cpus.length,
+ threads: cpus.length,
+ speedMhz: cpus[0].speed,
+ };
+}
+
+function scanRam(): RamInfo {
+ const totalBytes = os.totalmem();
+ const freeBytes = os.freemem();
+ return {
+ totalGb: Math.round((totalBytes / (1024 ** 3)) * 10) / 10,
+ availableGb: Math.round((freeBytes / (1024 ** 3)) * 10) / 10,
+ };
+}
+
+async function scanGpusWindows(): Promise<GpuInfo[]> {
+ const gpus: GpuInfo[] = [];
+
+ // Try WMIC first for all GPUs
+ try {
+ const { stdout } = await execAsync(
+ 'wmic path win32_videocontroller get Name,AdapterRAM,DriverVersion /format:csv',
+ { timeout: 10000 },
+ );
+ const lines = stdout.trim().split('\n').filter(l => l.trim().length > 0);
+ // First line is header: Node,AdapterRAM,DriverVersion,Name
+ for (let i = 1; i < lines.length; i++) {
+ const parts = lines[i].split(',');
+ if (parts.length < 4) continue;
+ const adapterRam = parseInt(parts[1], 10);
+ const name = parts[3]?.trim() || 'Unknown GPU';
+ const isNvidia = name.toLowerCase().includes('nvidia');
+ const isAmd = name.toLowerCase().includes('amd') || name.toLowerCase().includes('radeon');
+ gpus.push({
+ name,
+ vendor: isNvidia ? 'NVIDIA' : isAmd ? 'AMD' : 'Other',
+ vramMb: isNaN(adapterRam) ? null : Math.round(adapterRam / (1024 * 1024)),
+ cudaAvailable: false, // Filled in below
+ cudaVersion: null,
+ });
+ }
+ } catch {
+ // WMIC not available or failed
+ }
+
+ // Try nvidia-smi for CUDA info
+ try {
+ const { stdout } = await execAsync(
+ 'nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv,noheader,nounits',
+ { timeout: 10000 },
+ );
+ const lines = stdout.trim().split('\n');
+ for (const line of lines) {
+ const [name, vramMb, driverVersion] = line.split(',').map(s => s.trim());
+ // Try to find matching GPU from WMIC and enrich it
+ const existing = gpus.find(g => g.vendor === 'NVIDIA');
+ if (existing) {
+ existing.cudaAvailable = true;
+ existing.cudaVersion = driverVersion || null;
+ if (vramMb) {
+ existing.vramMb = parseInt(vramMb, 10);
+ }
+ } else {
+ gpus.push({
+ name: name || 'NVIDIA GPU',
+ vendor: 'NVIDIA',
+ vramMb: vramMb ? parseInt(vramMb, 10) : null,
+ cudaAvailable: true,
+ cudaVersion: driverVersion || null,
+ });
+ }
+ }
+ } catch {
+ // nvidia-smi not available β€” no CUDA
+ }
+
+ return gpus;
+}
+
+async function scanGpusMac(): Promise<GpuInfo[]> {
+ const gpus: GpuInfo[] = [];
+ try {
+ const { stdout } = await execAsync(
+ 'system_profiler SPDisplaysDataType',
+ { timeout: 10000 },
+ );
+ // Parse the output for chipset/VRAM info
+ const chipsetMatch = stdout.match(/Chipset Model:\s*(.+)/g);
+ const vramMatch = stdout.match(/VRAM.*?:\s*(\d+)\s*(MB|GB)/gi);
+ if (chipsetMatch) {
+ for (let i = 0; i < chipsetMatch.length; i++) {
+ const name = chipsetMatch[i].replace('Chipset Model:', '').trim();
+ let vramMb: number | null = null;
+ if (vramMatch && vramMatch[i]) {
+ const m = vramMatch[i].match(/(\d+)\s*(MB|GB)/i);
+ if (m) {
+ vramMb = parseInt(m[1], 10);
+ if (m[2].toUpperCase() === 'GB') vramMb *= 1024;
+ }
+ }
+ const isApple = name.toLowerCase().includes('apple');
+ gpus.push({
+ name,
+ vendor: isApple ? 'Apple' : 'Other',
+ vramMb,
+ cudaAvailable: false,
+ cudaVersion: null,
+ });
+ }
+ }
+ } catch {
+ // system_profiler failed
+ }
+ return gpus;
+}
+
+async function scanGpusLinux(): Promise<GpuInfo[]> {
+ const gpus: GpuInfo[] = [];
+
+ // lspci for GPU detection
+ try {
+ const { stdout } = await execAsync(
+ 'lspci | grep -iE "vga|3d|display"',
+ { timeout: 10000 },
+ );
+ for (const line of stdout.trim().split('\n')) {
+ if (!line.trim()) continue;
+ const name = line.replace(/^.*:\s*/, '').trim();
+ const isNvidia = name.toLowerCase().includes('nvidia');
+ const isAmd = name.toLowerCase().includes('amd') || name.toLowerCase().includes('radeon');
+ gpus.push({
+ name,
+ vendor: isNvidia ? 'NVIDIA' : isAmd ? 'AMD' : 'Other',
+ vramMb: null,
+ cudaAvailable: false,
+ cudaVersion: null,
+ });
+ }
+ } catch {
+ // lspci not available
+ }
+
+ // nvidia-smi for CUDA
+ try {
+ const { stdout } = await execAsync(
+ 'nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv,noheader,nounits',
+ { timeout: 10000 },
+ );
+ const lines = stdout.trim().split('\n');
+ for (const line of lines) {
+ const [name, vramMb, driverVersion] = line.split(',').map(s => s.trim());
+ const existing = gpus.find(g => g.vendor === 'NVIDIA');
+ if (existing) {
+ existing.cudaAvailable = true;
+ existing.cudaVersion = driverVersion || null;
+ if (vramMb) existing.vramMb = parseInt(vramMb, 10);
+ } else {
+ gpus.push({
+ name: name || 'NVIDIA GPU',
+ vendor: 'NVIDIA',
+ vramMb: vramMb ? parseInt(vramMb, 10) : null,
+ cudaAvailable: true,
+ cudaVersion: driverVersion || null,
+ });
+ }
+ }
+ } catch {
+ // no nvidia-smi
+ }
+
+ return gpus;
+}
+
+async function scanGpus(): Promise<GpuInfo[]> {
+ switch (process.platform) {
+ case 'win32': return scanGpusWindows();
+ case 'darwin': return scanGpusMac();
+ case 'linux': return scanGpusLinux();
+ default: return [];
+ }
+}
+
+async function scanDisk(): Promise<DiskInfo> {
+ const dataDir = path.join(app.getPath('home'), 'freemocap_data');
+ // Use the drive/mount that the data directory lives on
+ const targetPath = fs.existsSync(dataDir) ? dataDir : app.getPath('home');
+
+ try {
+ const stats = fs.statfsSync(targetPath);
+ const blockSize = stats.bsize;
+ const totalGb = Math.round((stats.blocks * blockSize) / (1024 ** 3) * 10) / 10;
+ const freeGb = Math.round((stats.bavail * blockSize) / (1024 ** 3) * 10) / 10;
+ return { path: targetPath, totalGb, freeGb };
+ } catch {
+ // statfsSync not available (very old Node) β€” return unknowns
+ return { path: targetPath, totalGb: 0, freeGb: 0 };
+ }
+}
+
+function scanOs(): OsInfo {
+ return {
+ platform: process.platform,
+ release: os.release(),
+ arch: os.arch(),
+ hostname: os.hostname(),
+ };
+}
+
+// ── Performance Recommendation ──
+
+function computeRecommendation(
+ cpu: CpuInfo,
+ ram: RamInfo,
+ gpus: GpuInfo[],
+ disk: DiskInfo,
+): PerformanceRecommendation {
+ const warnings: string[] = [];
+ const bestGpu = gpus.reduce<GpuInfo | null>((best, gpu) => {
+ if (!best) return gpu;
+ if (gpu.cudaAvailable && !best.cudaAvailable) return gpu;
+ if ((gpu.vramMb ?? 0) > (best.vramMb ?? 0)) return gpu;
+ return best;
+ }, null);
+
+ const hasCuda = bestGpu?.cudaAvailable ?? false;
+ const vramMb = bestGpu?.vramMb ?? 0;
+
+ // Disk warnings
+ if (disk.freeGb > 0 && disk.freeGb < 20) {
+ warnings.push(`Low disk space: ${disk.freeGb} GB free. Recordings can use 1-5 GB each.`);
+ }
+
+ // RAM warnings
+ if (ram.totalGb < 8) {
+ warnings.push('Less than 8 GB RAM β€” performance may be limited even with few cameras.');
+ }
+
+ // GPU warnings
+ if (gpus.length === 0) {
+ warnings.push('No dedicated GPU detected. Real-time pose tracking will not be available.');
+ } else if (!hasCuda) {
+ warnings.push('No NVIDIA GPU with CUDA detected. Mediapipe GPU acceleration will be unavailable.');
+ }
+
+ // Tier computation
+ let tier: PerformanceTier;
+ let label: string;
+ let description: string;
+ let maxCameras: number;
+ let maxResolution: string;
+ let realtimeTracking: boolean;
+
+ if (cpu.threads >= 12 && ram.totalGb >= 32 && hasCuda && vramMb >= 8000) {
+ tier = 'pro';
+ label = 'Pro';
+ description = 'Excellent system. Handles large multi-camera setups with real-time tracking and post-processing.';
+ maxCameras = 8;
+ maxResolution = '1080p';
+ realtimeTracking = true;
+ } else if (cpu.threads >= 8 && ram.totalGb >= 16 && hasCuda && vramMb >= 4000) {
+ tier = 'advanced';
+ label = 'Advanced';
+ description = 'Strong system. Supports several cameras with real-time tracking.';
+ maxCameras = 5;
+ maxResolution = '1080p';
+ realtimeTracking = true;
+ } else if (cpu.threads >= 4 && ram.totalGb >= 12) {
+ tier = 'standard';
+ label = 'Standard';
+ description = 'Good for multi-camera recording with offline processing.';
+ maxCameras = 3;
+ maxResolution = '720p';
+ realtimeTracking = false;
+ if (!hasCuda) {
+ warnings.push('Pose estimation will run on CPU β€” processing will be slower but functional.');
+ }
+ } else {
+ tier = 'basic';
+ label = 'Basic';
+ description = 'Can record from one or two cameras. Processing will be slow.';
+ maxCameras = 2;
+ maxResolution = '720p';
+ realtimeTracking = false;
+ }
+
+ return { tier, label, description, maxCameras, maxResolution, realtimeTracking, warnings };
+}
+
+// ── Public API ──
+
+export class SystemScanner {
+ static async scan(): Promise<SystemScanResult> {
+ const [cpu, ram, gpus, disk] = await Promise.all([
+ scanCpu(),
+ scanRam(),
+ scanGpus(),
+ scanDisk(),
+ ]);
+ const osInfo = scanOs();
+ const recommendation = computeRecommendation(cpu, ram, gpus, disk);
+
+ return {
+ cpu,
+ ram,
+ gpus,
+ disk,
+ os: osInfo,
+ recommendation,
+ scannedAt: new Date().toISOString(),
+ };
+ }
+}
diff --git a/freemocap-ui-old/electron-old/main/services/window-manager.ts b/freemocap-ui-old/electron-old/main/services/window-manager.ts
new file mode 100644
index 00000000..1e2f219a
--- /dev/null
+++ b/freemocap-ui-old/electron-old/main/services/window-manager.ts
@@ -0,0 +1,103 @@
+import { BrowserWindow, shell } from 'electron';
+import { LifecycleLogger } from './logger';
+import { APP_ENVIRONMENT } from '../index';
+import { APP_PATHS } from '../app-paths';
+
+export class WindowManager {
+ private static mainWindow: BrowserWindow | null = null;
+
+ static createMainWindow(): BrowserWindow {
+ if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+ return this.mainWindow;
+ }
+
+ const window = new BrowserWindow({
+ title: 'FreeMoCap πŸ’€πŸ“Έ',
+ icon: APP_PATHS.FREEMOCAP_ICON_PATH,
+ width: 1280,
+ height: 720,
+ minWidth: 800,
+ minHeight: 600,
+ webPreferences: {
+ preload: APP_PATHS.PRELOAD,
+ contextIsolation: true,
+ nodeIntegration: false,
+ sandbox: true,
+ },
+ show: false,
+ });
+
+ this.mainWindow = window;
+ this.configureWindowHandlers(window);
+ this.loadContent(window);
+
+ window.once('ready-to-show', () => {
+ window.show();
+ LifecycleLogger.logWindowCreation(window);
+ });
+
+ return window;
+ }
+
+ private static configureWindowHandlers(window: BrowserWindow): void {
+ console.log('Configuring window handlers');
+
+ window.on('closed', () => {
+ console.log('Window closed');
+ this.mainWindow = null;
+ });
+
+ window.webContents.on('did-finish-load', () => {
+ console.log('Window finished loading');
+ window.webContents.send('app-ready', Date.now());
+ });
+
+ window.webContents.setWindowOpenHandler(({ url }) => {
+ if (url.startsWith('http:') || url.startsWith('https:')) {
+ shell.openExternal(url).catch(err =>
+ console.error('Failed to open external link:', err),
+ );
+ }
+ return { action: 'deny' };
+ });
+
+ window.webContents.on('will-navigate', (event, url) => {
+ if (APP_ENVIRONMENT.IS_DEV && url.startsWith(APP_ENVIRONMENT.VITE_DEV_SERVER_URL!)) {
+ return;
+ }
+
+ if (!APP_ENVIRONMENT.IS_DEV && url.startsWith('file://')) {
+ return;
+ }
+
+ if (url.startsWith('http:') || url.startsWith('https:')) {
+ event.preventDefault();
+ shell.openExternal(url).catch(err =>
+ console.error('Failed to open external link via navigation:', err),
+ );
+ }
+ });
+
+ window.webContents.on('render-process-gone', (event, details) => {
+ console.error('Renderer process gone:', details);
+ if (details.reason === 'crashed') {
+ window.reload();
+ }
+ });
+ }
+
+ private static loadContent(window: BrowserWindow): void {
+ console.log('Loading app content - IS_DEV:', APP_ENVIRONMENT.IS_DEV);
+
+ if (APP_ENVIRONMENT.IS_DEV && APP_ENVIRONMENT.VITE_DEV_SERVER_URL) {
+ window.loadURL(APP_ENVIRONMENT.VITE_DEV_SERVER_URL);
+ // window.webContents.openDevTools();
+ } else {
+ window.loadFile(APP_PATHS.RENDERER_HTML);
+ }
+ }
+
+ static getMainWindow(): BrowserWindow | null {
+ return this.mainWindow;
+ }
+}
diff --git a/freemocap-ui-old/electron-old/preload/index.ts b/freemocap-ui-old/electron-old/preload/index.ts
new file mode 100644
index 00000000..2096156c
--- /dev/null
+++ b/freemocap-ui-old/electron-old/preload/index.ts
@@ -0,0 +1,17 @@
+import { contextBridge, ipcRenderer } from 'electron';
+
+contextBridge.exposeInMainWorld('electronAPI', {
+ // tRPC bridge
+ invoke: (path: string, input?: any) =>
+ ipcRenderer.invoke('trpc', { path, input }),
+
+ // Menu-triggered navigation: main process sends 'navigate' with a route string
+ onNavigate: (callback: (route: string) => void) => {
+ const handler = (_event: Electron.IpcRendererEvent, route: string) => callback(route);
+ ipcRenderer.on('navigate', handler);
+ // Return cleanup function
+ return () => {
+ ipcRenderer.removeListener('navigate', handler);
+ };
+ },
+});
diff --git a/freemocap/tests/test_e2e_pipeline.py b/freemocap/tests/test_e2e_pipeline.py
new file mode 100644
index 00000000..979a3338
--- /dev/null
+++ b/freemocap/tests/test_e2e_pipeline.py
@@ -0,0 +1,317 @@
+"""
+End-to-end pipeline tests: calibration β†’ mocap β†’ blender export.
+
+These tests run the full real pipeline against FREEMOCAP_TEST_DATA_PATH.
+They are marked with @pytest.mark.e2e and require test data on disk.
+
+Run with:
+ pytest freemocap/tests/test_e2e_pipeline.py -v -s --timeout=600
+
+Skip in fast CI with:
+ pytest freemocap/tests/ -m "not e2e"
+"""
+import multiprocessing
+import time
+from pathlib import Path
+
+import cv2
+import numpy as np
+import pytest
+from skellycam.core.ipc.process_management.managed_worker import WorkerMode
+from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry
+from skellycam.core.recorders.videos.recording_info import RecordingInfo
+
+from freemocap.core.calibration.shared.calibration_paths import (
+ get_last_successful_calibration_toml_path,
+)
+from freemocap.core.pipeline.pipeline_configs import (
+ CalibrationPipelineConfig,
+ MocapPipelineConfig,
+)
+from freemocap.core.pipeline.posthoc.posthoc_pipeline import PosthocPipeline
+from freemocap.core.pipeline.posthoc.posthoc_pipeline_manager import PosthocPipelineManager
+from freemocap.system.default_paths import FREEMOCAP_TEST_DATA_PATH
+
+PIPELINE_TIMEOUT_SECONDS = 600
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _wait_for_pipeline(pipeline: PosthocPipeline, timeout: float = PIPELINE_TIMEOUT_SECONDS) -> None:
+ """Poll until the pipeline finishes or timeout is reached."""
+ start = time.monotonic()
+ while pipeline.alive:
+ if time.monotonic() - start > timeout:
+ pipeline.shutdown()
+ raise TimeoutError(
+ f"Pipeline [{pipeline.id}] did not complete within {timeout}s"
+ )
+ time.sleep(1.0)
+
+
+def _recording_info_from_path(recording_path: Path) -> RecordingInfo:
+ return RecordingInfo(
+ recording_directory=str(recording_path.parent),
+ recording_name=recording_path.stem,
+ mic_device_index=-1,
+ )
+
+
+# ---------------------------------------------------------------------------
+# Session-scoped fixtures
+# ---------------------------------------------------------------------------
+
+
[email protected](scope="session")
+def test_data_path() -> Path:
+ path = Path(FREEMOCAP_TEST_DATA_PATH)
+ if not path.exists():
+ pytest.skip(
+ f"Test data not found at {path}. "
+ "Download it first or set FREEMOCAP_TEST_DATA_PATH."
+ )
+ sync_videos = path / "synchronized_videos"
+ if not sync_videos.exists() or not list(sync_videos.glob("*.mp4")):
+ pytest.skip(f"No synchronized_videos found in {path}")
+ return path
+
+
[email protected](scope="session")
+def global_kill_flag():
+ return multiprocessing.Value("b", False)
+
+
[email protected](scope="session")
+def worker_registry(global_kill_flag):
+ return WorkerRegistry(
+ global_kill_flag=global_kill_flag,
+ worker_mode=WorkerMode.THREAD,
+ )
+
+
[email protected](scope="session")
+def pipeline_manager(global_kill_flag, worker_registry) -> PosthocPipelineManager:
+ manager = PosthocPipelineManager(
+ global_kill_flag=global_kill_flag,
+ worker_registry=worker_registry,
+ )
+ yield manager
+ manager.shutdown()
+
+
[email protected](scope="session")
+def calibration_toml_path(test_data_path: Path, pipeline_manager: PosthocPipelineManager) -> Path:
+ """
+ Run calibration once for the whole test session.
+ Returns the path to the written calibration TOML.
+ """
+ recording_info = _recording_info_from_path(test_data_path)
+ pipeline = pipeline_manager.create_calibration_pipeline(
+ recording_info=recording_info,
+ calibration_config=CalibrationPipelineConfig(),
+ )
+ _wait_for_pipeline(pipeline)
+
+ toml_path = get_last_successful_calibration_toml_path()
+ if not toml_path.exists():
+ pytest.fail(f"Calibration completed but TOML not found at {toml_path}")
+ return toml_path
+
+
+# ---------------------------------------------------------------------------
+# Calibration pipeline tests
+# ---------------------------------------------------------------------------
+
+
+class TestCalibrationPipeline:
+
+ def test_calibration_produces_toml_in_recording_folder(
+ self, test_data_path: Path, calibration_toml_path: Path
+ ) -> None:
+ # calibration_toml_path fixture already ran calibration; verify recording-local copy
+ expected = test_data_path / f"{test_data_path.stem}_camera_calibration.toml"
+ assert expected.exists(), f"Expected recording-local TOML at {expected}"
+
+ def test_calibration_updates_last_successful_toml(
+ self, calibration_toml_path: Path
+ ) -> None:
+ assert calibration_toml_path.exists(), (
+ f"last_successful_camera_calibration.toml not found at {calibration_toml_path}"
+ )
+ assert calibration_toml_path.stat().st_size > 0
+
+ def test_calibration_annotated_videos_match_source_resolution_and_frame_count(
+ self, test_data_path: Path, calibration_toml_path: Path
+ ) -> None:
+ annotated_dir = test_data_path / "annotated_videos"
+ assert annotated_dir.exists(), f"annotated_videos/ not found in {test_data_path}"
+
+ sync_videos_dir = test_data_path / "synchronized_videos"
+ source_videos = sorted(sync_videos_dir.glob("*.mp4"))
+ annotated_videos = sorted(annotated_dir.glob("*.mp4"))
+
+ assert len(annotated_videos) > 0, "No annotated videos produced"
+ assert len(annotated_videos) == len(source_videos), (
+ f"Annotated video count ({len(annotated_videos)}) != "
+ f"source video count ({len(source_videos)})"
+ )
+
+ for ann_path, src_path in zip(annotated_videos, source_videos):
+ ann = cv2.VideoCapture(str(ann_path))
+ src = cv2.VideoCapture(str(src_path))
+ try:
+ ann_w = int(ann.get(cv2.CAP_PROP_FRAME_WIDTH))
+ ann_h = int(ann.get(cv2.CAP_PROP_FRAME_HEIGHT))
+ ann_n = int(ann.get(cv2.CAP_PROP_FRAME_COUNT))
+ src_w = int(src.get(cv2.CAP_PROP_FRAME_WIDTH))
+ src_h = int(src.get(cv2.CAP_PROP_FRAME_HEIGHT))
+ src_n = int(src.get(cv2.CAP_PROP_FRAME_COUNT))
+ assert ann_w == src_w, f"{ann_path.name}: width {ann_w} != {src_w}"
+ assert ann_h == src_h, f"{ann_path.name}: height {ann_h} != {src_h}"
+ assert ann_n == src_n, f"{ann_path.name}: frames {ann_n} != {src_n}"
+ finally:
+ ann.release()
+ src.release()
+
+
+# ---------------------------------------------------------------------------
+# Mocap pipeline tests
+# ---------------------------------------------------------------------------
+
+
+def _run_mocap_and_wait(
+ test_data_path: Path,
+ pipeline_manager: PosthocPipelineManager,
+ calibration_toml_path_override: str | None,
+) -> None:
+ mocap_config = MocapPipelineConfig.default_posthoc()
+ if calibration_toml_path_override is not None:
+ mocap_config = mocap_config.model_copy(
+ update={"calibration_toml_path": calibration_toml_path_override}
+ )
+ recording_info = _recording_info_from_path(test_data_path)
+ pipeline = pipeline_manager.create_mocap_pipeline(
+ recording_info=recording_info,
+ mocap_config=mocap_config,
+ )
+ _wait_for_pipeline(pipeline)
+
+
+class TestMocapPipeline:
+
+ @pytest.fixture(scope="class", autouse=True)
+ def run_mocap_implicit_calibration(
+ self, test_data_path: Path, pipeline_manager: PosthocPipelineManager, calibration_toml_path: Path
+ ) -> None:
+ """Run mocap using the implicit 'most recent calibration' (None path)."""
+ _run_mocap_and_wait(test_data_path, pipeline_manager, calibration_toml_path_override=None)
+
+ def test_output_data_folder_exists(self, test_data_path: Path) -> None:
+ output_dir = test_data_path / "output_data"
+ assert output_dir.exists(), f"output_data/ not found in {test_data_path}"
+
+ def test_npy_files_present(self, test_data_path: Path) -> None:
+ output_dir = test_data_path / "output_data"
+ npy_files = list(output_dir.glob("*.npy"))
+ assert len(npy_files) > 0, f"No .npy files found in {output_dir}"
+
+ def test_csv_files_present(self, test_data_path: Path) -> None:
+ output_dir = test_data_path / "output_data"
+ csv_files = list(output_dir.glob("*.csv"))
+ assert len(csv_files) > 0, f"No .csv files found in {output_dir}"
+
+ def test_body_npy_has_correct_shape(self, test_data_path: Path) -> None:
+ output_dir = test_data_path / "output_data"
+ npy_files = list(output_dir.glob("*.npy"))
+ # Find the main body 3D data file
+ body_files = [f for f in npy_files if "body" in f.stem.lower() and "3d" in f.stem.lower()]
+ if not body_files:
+ body_files = [f for f in npy_files if "body" in f.stem.lower()]
+ assert body_files, f"No body npy found in {output_dir}. Files: {[f.name for f in npy_files]}"
+ data = np.load(body_files[0])
+ assert data.ndim >= 2, f"Expected at least 2D array, got shape {data.shape}"
+ assert not np.all(np.isnan(data)), "Body data is all NaN β€” triangulation likely failed"
+
+ def test_mocap_annotated_videos_match_source(self, test_data_path: Path) -> None:
+ annotated_dir = test_data_path / "annotated_videos"
+ sync_dir = test_data_path / "synchronized_videos"
+ if not annotated_dir.exists():
+ pytest.skip("annotated_videos/ not present (may be skipped in config)")
+ source_videos = sorted(sync_dir.glob("*.mp4"))
+ annotated_videos = sorted(annotated_dir.glob("*.mp4"))
+ assert len(annotated_videos) == len(source_videos)
+ for ann_path, src_path in zip(annotated_videos, source_videos):
+ ann = cv2.VideoCapture(str(ann_path))
+ src = cv2.VideoCapture(str(src_path))
+ try:
+ assert int(ann.get(cv2.CAP_PROP_FRAME_WIDTH)) == int(src.get(cv2.CAP_PROP_FRAME_WIDTH))
+ assert int(ann.get(cv2.CAP_PROP_FRAME_HEIGHT)) == int(src.get(cv2.CAP_PROP_FRAME_HEIGHT))
+ assert int(ann.get(cv2.CAP_PROP_FRAME_COUNT)) == int(src.get(cv2.CAP_PROP_FRAME_COUNT))
+ finally:
+ ann.release()
+ src.release()
+
+
+class TestMocapWithExplicitCalibrationPath:
+ """Re-run mocap with an explicitly provided calibration TOML path."""
+
+ @pytest.fixture(scope="class", autouse=True)
+ def run_mocap_explicit_calibration(
+ self,
+ test_data_path: Path,
+ pipeline_manager: PosthocPipelineManager,
+ calibration_toml_path: Path,
+ ) -> None:
+ _run_mocap_and_wait(
+ test_data_path,
+ pipeline_manager,
+ calibration_toml_path_override=str(calibration_toml_path),
+ )
+
+ def test_output_data_folder_exists(self, test_data_path: Path) -> None:
+ output_dir = test_data_path / "output_data"
+ assert output_dir.exists()
+
+ def test_npy_files_present(self, test_data_path: Path) -> None:
+ output_dir = test_data_path / "output_data"
+ assert len(list(output_dir.glob("*.npy"))) > 0
+
+ def test_csv_files_present(self, test_data_path: Path) -> None:
+ output_dir = test_data_path / "output_data"
+ assert len(list(output_dir.glob("*.csv"))) > 0
+
+
+# ---------------------------------------------------------------------------
+# Blender export tests
+# ---------------------------------------------------------------------------
+
+
+class TestBlenderExport:
+
+ @pytest.fixture(scope="class", autouse=True)
+ def run_blender_export(
+ self, test_data_path: Path, calibration_toml_path: Path
+ ) -> None:
+ """Run blender export after mocap has produced output_data/."""
+ from freemocap.core.blender.export_to_blender import export_to_blender
+
+ output_dir = test_data_path / "output_data"
+ if not output_dir.exists() or not list(output_dir.glob("*.npy")):
+ pytest.skip("output_data/ not present β€” run mocap tests first")
+
+ export_to_blender(recording_folder_path=str(test_data_path))
+
+ def test_blend_file_exists(self, test_data_path: Path) -> None:
+ blend_file = test_data_path / f"{test_data_path.stem}.blend"
+ assert blend_file.exists(), f"Expected .blend file at {blend_file}"
+
+ def test_blend_file_is_non_empty(self, test_data_path: Path) -> None:
+ blend_file = test_data_path / f"{test_data_path.stem}.blend"
+ assert blend_file.stat().st_size > 0, ".blend file is empty"