Skip to content

Free Motion Capture for Everyone 💀✨

TypeScript

theoretically blender

jonmatthisc12757896908
diff --git a/freemocap-ui/src/components/control-panels/mocap-control-panel/BlenderSection.tsx b/freemocap-ui/src/components/control-panels/mocap-control-panel/BlenderSection.tsx
new file mode 100644
index 00000000..7395e8ff
--- /dev/null
+++ b/freemocap-ui/src/components/control-panels/mocap-control-panel/BlenderSection.tsx
@@ -0,0 +1,186 @@
+import React from 'react';
+import {
+ Alert,
+ Box,
+ Button,
+ Checkbox,
+ Divider,
+ FormControlLabel,
+ IconButton,
+ InputAdornment,
+ Stack,
+ TextField,
+ Tooltip,
+ Typography,
+} from '@mui/material';
+import FolderOpenIcon from '@mui/icons-material/FolderOpen';
+import RefreshIcon from '@mui/icons-material/Refresh';
+import ClearIcon from '@mui/icons-material/Clear';
+import MovieFilterIcon from '@mui/icons-material/MovieFilter';
+import {useBlender} from '@/hooks/useBlender';
+import {useElectronIPC} from '@/services';
+
+interface BlenderSectionProps {
+ recordingFolderPath: string | null | undefined;
+ disabled?: boolean;
+}
+
+export const BlenderSection: React.FC<BlenderSectionProps> = ({
+ recordingFolderPath,
+ disabled = false,
+}) => {
+ const {api, isElectron} = useElectronIPC();
+ const {
+ effectiveBlenderExePath,
+ isUsingManualBlenderPath,
+ exportToBlenderEnabled,
+ autoOpenBlendFile,
+ isExporting,
+ isDetecting,
+ lastBlendFilePath,
+ error,
+ redetectBlender,
+ setBlenderExePath,
+ clearBlenderExePath,
+ setExportToBlenderEnabled,
+ setAutoOpenBlendFile,
+ triggerBlenderExport,
+ clearError,
+ } = useBlender();
+
+ const handleSelectBlenderExe = async (): Promise<void> => {
+ if (!isElectron || !api) return;
+ try {
+ const result: string | null = await api.fileSystem.selectExecutableFile.mutate();
+ if (result) {
+ setBlenderExePath(result);
+ }
+ } catch (err) {
+ console.error('Failed to select Blender executable:', err);
+ }
+ };
+
+ const handleProcessWithBlender = (): void => {
+ if (!recordingFolderPath) return;
+ void triggerBlenderExport(recordingFolderPath);
+ };
+
+ const canExport =
+ !!recordingFolderPath &&
+ !!effectiveBlenderExePath &&
+ !isExporting &&
+ !disabled;
+
+ return (
+ <Box sx={{mt: 1}}>
+ <Divider sx={{mb: 2}}>
+ <Stack direction="row" alignItems="center" spacing={0.5}>
+ <MovieFilterIcon fontSize="small"/>
+ <Typography variant="overline" sx={{lineHeight: 1}}>
+ Blender
+ </Typography>
+ </Stack>
+ </Divider>
+
+ <Stack spacing={2}>
+ {error && (
+ <Alert severity="error" onClose={clearError}>
+ {error}
+ </Alert>
+ )}
+
+ <TextField
+ label="Blender Executable"
+ value={effectiveBlenderExePath ?? ''}
+ onChange={(e) => setBlenderExePath(e.target.value || null)}
+ fullWidth
+ size="small"
+ placeholder={isDetecting ? 'Detecting…' : 'No Blender found — select manually'}
+ helperText={
+ isUsingManualBlenderPath
+ ? 'Using manually selected Blender'
+ : effectiveBlenderExePath
+ ? 'Auto-detected Blender'
+ : 'Click the folder icon to browse for blender.exe'
+ }
+ InputProps={{
+ endAdornment: (
+ <InputAdornment position="end">
+ {isUsingManualBlenderPath && (
+ <Tooltip title="Clear manual path (revert to auto-detected)">
+ <IconButton onClick={clearBlenderExePath} edge="end" size="small">
+ <ClearIcon fontSize="small"/>
+ </IconButton>
+ </Tooltip>
+ )}
+ <Tooltip title="Re-detect Blender">
+ <span>
+ <IconButton
+ onClick={redetectBlender}
+ edge="end"
+ size="small"
+ disabled={isDetecting}
+ >
+ <RefreshIcon fontSize="small"/>
+ </IconButton>
+ </span>
+ </Tooltip>
+ <Tooltip title="Select Blender executable">
+ <span>
+ <IconButton
+ onClick={handleSelectBlenderExe}
+ edge="end"
+ disabled={!isElectron}
+ >
+ <FolderOpenIcon/>
+ </IconButton>
+ </span>
+ </Tooltip>
+ </InputAdornment>
+ ),
+ }}
+ />
+
+ <Stack spacing={0.5}>
+ <FormControlLabel
+ control={
+ <Checkbox
+ size="small"
+ checked={exportToBlenderEnabled}
+ onChange={(e) => setExportToBlenderEnabled(e.target.checked)}
+ />
+ }
+ label="Export to Blender after mocap processing"
+ />
+ <FormControlLabel
+ control={
+ <Checkbox
+ size="small"
+ checked={autoOpenBlendFile}
+ onChange={(e) => setAutoOpenBlendFile(e.target.checked)}
+ />
+ }
+ label="Auto-open .blend file in Blender when done"
+ />
+ </Stack>
+
+ <Button
+ variant="outlined"
+ color="secondary"
+ startIcon={<MovieFilterIcon/>}
+ onClick={handleProcessWithBlender}
+ disabled={!canExport}
+ fullWidth
+ >
+ {isExporting ? 'Exporting to Blender…' : 'Process Recording with Blender'}
+ </Button>
+
+ {lastBlendFilePath && (
+ <Typography variant="caption" color="text.secondary" sx={{fontFamily: 'monospace'}}>
+ Last export: {lastBlendFilePath}
+ </Typography>
+ )}
+ </Stack>
+ </Box>
+ );
+};
diff --git a/freemocap-ui/src/components/control-panels/mocap-control-panel/MocapPanel.tsx b/freemocap-ui/src/components/control-panels/mocap-control-panel/MocapPanel.tsx
index c083f46f..448b7683 100644
--- a/freemocap-ui/src/components/control-panels/mocap-control-panel/MocapPanel.tsx
+++ b/freemocap-ui/src/components/control-panels/mocap-control-panel/MocapPanel.tsx
@@ -32,6 +32,7 @@ import {RealtimePipelineConfigTree} from "@/components/control-panels/realtime-p
import {useServer} from "@/services/server/ServerContextProvider";
import SquareFootIcon from "@mui/icons-material/SquareFoot";
import {CollapsibleSidebarSection} from "@/components/common/CollapsibleSidebarSection";
+import {BlenderSection} from "@/components/control-panels/mocap-control-panel/BlenderSection";
export const MocapPanel: React.FC = () => {
const theme = useTheme();
@@ -67,6 +68,11 @@ export const MocapPanel: React.FC = () => {
directoryInfo: calibrationDirectoryInfo,
} = useCalibration();
+ // Blender export is driven by the backend aggregator via config flags
+ // (state.blender.*), which mocap-thunks.ts folds into the process request.
+ // The standalone "Process Recording with Blender" button inside
+ // BlenderSection remains available for manual re-exports.
+
// Auto-poll directory status
const {triggerRefresh} = useDirectoryWatcher(
mocapRecordingPath,
@@ -81,6 +87,7 @@ export const MocapPanel: React.FC = () => {
useEffect(() => {
setOverlayVisibility(charucoEnabled, skeletonEnabled);
}, [charucoEnabled, skeletonEnabled, setOverlayVisibility]);
+
const [triangulateEnabled, setTriangulateEnabled] = useState(true);
const [filterEnabled, setFilterEnabled] = useState(true);
const [rigidBodyEnabled, setRigidBodyEnabled] = useState(true);
@@ -403,6 +410,11 @@ export const MocapPanel: React.FC = () => {
rigidBodyEnabled={rigidBodyEnabled}
onRigidBodyToggle={setRigidBodyEnabled}
/>
+
+ <BlenderSection
+ recordingFolderPath={mocapRecordingPath}
+ disabled={isLoading}
+ />
</Stack>
</Box>
</CollapsibleSidebarSection>
diff --git a/freemocap-ui/src/constants/server-urls.ts b/freemocap-ui/src/constants/server-urls.ts
index 30aeec96..5b76effa 100644
--- a/freemocap-ui/src/constants/server-urls.ts
+++ b/freemocap-ui/src/constants/server-urls.ts
@@ -81,6 +81,10 @@ class ServerUrls {
mocapStopRecording: `${baseUrl}/freemocap/mocap/recording/stop`,
processMocapRecording: `${baseUrl}/freemocap/mocap/recording/process`,
+ // Blender endpoints
+ blenderDetect: `${baseUrl}/freemocap/blender/detect`,
+ blenderExport: `${baseUrl}/freemocap/blender/export`,
+
// WebSocket
websocket: this.getWebSocketUrl(),
};
diff --git a/freemocap-ui/src/hooks/useBlender.ts b/freemocap-ui/src/hooks/useBlender.ts
new file mode 100644
index 00000000..c55d2f33
--- /dev/null
+++ b/freemocap-ui/src/hooks/useBlender.ts
@@ -0,0 +1,89 @@
+import {useCallback, useEffect} from 'react';
+import {useAppDispatch, useAppSelector} from '@/store/hooks';
+import {
+ autoOpenBlendFileToggled,
+ blenderErrorCleared,
+ blenderExePathChanged,
+ blenderExePathCleared,
+ detectBlender,
+ exportRecordingToBlender,
+ exportToBlenderToggled,
+ selectBlender,
+ selectEffectiveBlenderExePath,
+} from '@/store/slices/blender';
+
+export function useBlender() {
+ const dispatch = useAppDispatch();
+ const blender = useAppSelector(selectBlender);
+ const effectiveBlenderExePath = useAppSelector(selectEffectiveBlenderExePath);
+
+ useEffect(() => {
+ if (blender.detectedBlenderExePath === null && !blender.isDetecting) {
+ void dispatch(detectBlender());
+ }
+ }, [dispatch, blender.detectedBlenderExePath, blender.isDetecting]);
+
+ const redetectBlender = useCallback(() => {
+ void dispatch(detectBlender());
+ }, [dispatch]);
+
+ const setBlenderExePath = useCallback(
+ (path: string | null) => {
+ dispatch(blenderExePathChanged(path));
+ },
+ [dispatch]
+ );
+
+ const clearBlenderExePath = useCallback(() => {
+ dispatch(blenderExePathCleared());
+ }, [dispatch]);
+
+ const setExportToBlenderEnabled = useCallback(
+ (enabled: boolean) => {
+ dispatch(exportToBlenderToggled(enabled));
+ },
+ [dispatch]
+ );
+
+ const setAutoOpenBlendFile = useCallback(
+ (enabled: boolean) => {
+ dispatch(autoOpenBlendFileToggled(enabled));
+ },
+ [dispatch]
+ );
+
+ const triggerBlenderExport = useCallback(
+ (recordingFolderPath?: string) => {
+ return dispatch(
+ exportRecordingToBlender(
+ recordingFolderPath ? {recordingFolderPath} : undefined
+ )
+ );
+ },
+ [dispatch]
+ );
+
+ const clearError = useCallback(() => {
+ dispatch(blenderErrorCleared());
+ }, [dispatch]);
+
+ return {
+ blenderExePath: blender.blenderExePath,
+ detectedBlenderExePath: blender.detectedBlenderExePath,
+ effectiveBlenderExePath,
+ exportToBlenderEnabled: blender.exportToBlenderEnabled,
+ autoOpenBlendFile: blender.autoOpenBlendFile,
+ isExporting: blender.isExporting,
+ isDetecting: blender.isDetecting,
+ lastBlendFilePath: blender.lastBlendFilePath,
+ error: blender.error,
+ isUsingManualBlenderPath: blender.blenderExePath !== null,
+ redetectBlender,
+ setBlenderExePath,
+ clearBlenderExePath,
+ setExportToBlenderEnabled,
+ setAutoOpenBlendFile,
+ triggerBlenderExport,
+ clearError,
+ };
+}
diff --git a/freemocap-ui/src/store/index.ts b/freemocap-ui/src/store/index.ts
index 7246a7b3..803e80ea 100644
--- a/freemocap-ui/src/store/index.ts
+++ b/freemocap-ui/src/store/index.ts
@@ -11,3 +11,4 @@ export * from './slices/videos';
export * from './slices/realtime';
export * from './slices/mocap';
export * from './slices/pipelines';
+export * from './slices/blender';
diff --git a/freemocap-ui/src/store/slices/blender/blender-slice.ts b/freemocap-ui/src/store/slices/blender/blender-slice.ts
new file mode 100644
index 00000000..31a903a1
--- /dev/null
+++ b/freemocap-ui/src/store/slices/blender/blender-slice.ts
@@ -0,0 +1,93 @@
+import {createSlice, PayloadAction} from '@reduxjs/toolkit';
+import {RootState} from '@/store/types';
+import {detectBlender, exportRecordingToBlender} from './blender-thunks';
+
+export interface BlenderState {
+ blenderExePath: string | null;
+ detectedBlenderExePath: string | null;
+ exportToBlenderEnabled: boolean;
+ autoOpenBlendFile: boolean;
+ isExporting: boolean;
+ isDetecting: boolean;
+ lastBlendFilePath: string | null;
+ error: string | null;
+}
+
+const initialState: BlenderState = {
+ blenderExePath: null,
+ detectedBlenderExePath: null,
+ exportToBlenderEnabled: true,
+ autoOpenBlendFile: true,
+ isExporting: false,
+ isDetecting: false,
+ lastBlendFilePath: null,
+ error: null,
+};
+
+export const blenderSlice = createSlice({
+ name: 'blender',
+ initialState,
+ reducers: {
+ blenderExePathChanged: (state, action: PayloadAction<string | null>) => {
+ state.blenderExePath = action.payload;
+ },
+ blenderExePathCleared: (state) => {
+ state.blenderExePath = null;
+ },
+ exportToBlenderToggled: (state, action: PayloadAction<boolean>) => {
+ state.exportToBlenderEnabled = action.payload;
+ },
+ autoOpenBlendFileToggled: (state, action: PayloadAction<boolean>) => {
+ state.autoOpenBlendFile = action.payload;
+ },
+ blenderErrorCleared: (state) => {
+ state.error = null;
+ },
+ },
+ extraReducers: (builder) => {
+ builder
+ .addCase(detectBlender.pending, (state) => {
+ state.isDetecting = true;
+ state.error = null;
+ })
+ .addCase(detectBlender.fulfilled, (state, action) => {
+ state.isDetecting = false;
+ state.detectedBlenderExePath = action.payload.blenderExePath ?? null;
+ })
+ .addCase(detectBlender.rejected, (state, action) => {
+ state.isDetecting = false;
+ state.error = action.payload || 'Failed to detect Blender';
+ });
+
+ builder
+ .addCase(exportRecordingToBlender.pending, (state) => {
+ state.isExporting = true;
+ state.error = null;
+ })
+ .addCase(exportRecordingToBlender.fulfilled, (state, action) => {
+ state.isExporting = false;
+ state.lastBlendFilePath = action.payload.blenderFilePath ?? null;
+ })
+ .addCase(exportRecordingToBlender.rejected, (state, action) => {
+ state.isExporting = false;
+ state.error = action.payload || 'Failed to export to Blender';
+ });
+ },
+});
+
+export const selectBlender = (state: RootState) => state.blender;
+export const selectBlenderExePath = (state: RootState) =>
+ state.blender.blenderExePath ?? state.blender.detectedBlenderExePath;
+export const selectEffectiveBlenderExePath = selectBlenderExePath;
+export const selectExportToBlenderEnabled = (state: RootState) => state.blender.exportToBlenderEnabled;
+export const selectAutoOpenBlendFile = (state: RootState) => state.blender.autoOpenBlendFile;
+
+export const {
+ blenderExePathChanged,
+ blenderExePathCleared,
+ exportToBlenderToggled,
+ autoOpenBlendFileToggled,
+ blenderErrorCleared,
+} = blenderSlice.actions;
+
+export default blenderSlice.reducer;
diff --git a/freemocap-ui/src/store/slices/blender/blender-thunks.ts b/freemocap-ui/src/store/slices/blender/blender-thunks.ts
new file mode 100644
index 00000000..043a3069
--- /dev/null
+++ b/freemocap-ui/src/store/slices/blender/blender-thunks.ts
@@ -0,0 +1,86 @@
+import {createAsyncThunk} from '@reduxjs/toolkit';
+import {RootState} from '@/store/types';
+import {serverUrls} from '@/services';
+import {getDetailedErrorMessage} from '@/store/slices/thunk-helpers';
+
+interface DetectBlenderResult {
+ blenderExePath: string | null;
+ found: boolean;
+ message?: string | null;
+}
+
+export const detectBlender = createAsyncThunk<
+ DetectBlenderResult,
+ void,
+ { state: RootState; rejectValue: string }
+>(
+ 'blender/detect',
+ async (_, {rejectWithValue}) => {
+ try {
+ const response = await fetch(serverUrls.endpoints.blenderDetect);
+ if (!response.ok) {
+ return rejectWithValue(await getDetailedErrorMessage(response));
+ }
+ const data = await response.json();
+ return {
+ blenderExePath: data.blender_exe_path ?? null,
+ found: !!data.found,
+ message: data.message ?? null,
+ };
+ } catch (e) {
+ return rejectWithValue(e instanceof Error ? e.message : 'Unknown error');
+ }
+ }
+);
+
+interface ExportBlenderResult {
+ success: boolean;
+ message?: string | null;
+ blenderFilePath?: string | null;
+}
+
+export const exportRecordingToBlender = createAsyncThunk<
+ ExportBlenderResult,
+ { recordingFolderPath: string } | void,
+ { state: RootState; rejectValue: string }
+>(
+ 'blender/export',
+ async (arg, {getState, rejectWithValue}) => {
+ try {
+ const state = getState();
+ const blender = state.blender;
+ const recordingFolderPath =
+ (arg && arg.recordingFolderPath) ||
+ state.mocap.manualMocapRecordingPath ||
+ state.mocap.lastMocapRecordingPath;
+
+ if (!recordingFolderPath) {
+ return rejectWithValue('No recording folder path available for Blender export');
+ }
+
+ const blenderExePath = blender.blenderExePath ?? blender.detectedBlenderExePath;
+
+ const response = await fetch(serverUrls.endpoints.blenderExport, {
+ method: 'POST',
+ headers: {'Content-Type': 'application/json'},
+ body: JSON.stringify({
+ recordingFolderPath,
+ blenderExePath,
+ autoOpenBlendFile: blender.autoOpenBlendFile,
+ }),
+ });
+
+ if (!response.ok) {
+ return rejectWithValue(await getDetailedErrorMessage(response));
+ }
+ const data = await response.json();
+ return {
+ success: !!data.success,
+ message: data.message ?? null,
+ blenderFilePath: data.blender_file_path ?? null,
+ };
+ } catch (e) {
+ return rejectWithValue(e instanceof Error ? e.message : 'Unknown error');
+ }
+ }
+);
diff --git a/freemocap-ui/src/store/slices/blender/index.ts b/freemocap-ui/src/store/slices/blender/index.ts
new file mode 100644
index 00000000..2393cb38
--- /dev/null
+++ b/freemocap-ui/src/store/slices/blender/index.ts
@@ -0,0 +1,2 @@
+export * from './blender-slice';
+export * from './blender-thunks';
diff --git a/freemocap-ui/src/store/slices/mocap/mocap-slice.ts b/freemocap-ui/src/store/slices/mocap/mocap-slice.ts
index 716972ea..d2aaeb97 100644
--- a/freemocap-ui/src/store/slices/mocap/mocap-slice.ts
+++ b/freemocap-ui/src/store/slices/mocap/mocap-slice.ts
@@ -344,10 +344,16 @@ export const selectCanProcessMocapRecording = createSelector(
selectMocapRecordingPath,
selectMocapIsLoading,
selectMocapIsRecording,
- selectMocapDirectoryInfo
+ selectMocapDirectoryInfo,
+ selectCalibrationTomlPath,
],
- (mocapPath, isLoading, isRecording, directoryInfo) => {
- return !!mocapPath && !isLoading && !isRecording && (directoryInfo?.canCalibrate ?? false);
+ (mocapPath, isLoading, isRecording, directoryInfo, manualCalibrationTomlPath) => {
+ const hasVideos = directoryInfo?.hasVideos ?? false;
+ const hasAnyCalibrationToml =
+ !!manualCalibrationTomlPath ||
+ !!directoryInfo?.cameraMocapTomlPath ||
+ !!directoryInfo?.lastSuccessfulCalibrationTomlPath;
+ return !!mocapPath && !isLoading && !isRecording && hasVideos && hasAnyCalibrationToml;
}
);
diff --git a/freemocap-ui/src/store/slices/mocap/mocap-thunks.ts b/freemocap-ui/src/store/slices/mocap/mocap-thunks.ts
index 6765d4be..f23ee01c 100644
--- a/freemocap-ui/src/store/slices/mocap/mocap-thunks.ts
+++ b/freemocap-ui/src/store/slices/mocap/mocap-thunks.ts
@@ -21,9 +21,13 @@ export const startMocapRecording = createAsyncThunk<
}
const calibrationTomlPath = state.mocap.calibrationTomlPath;
+ const blender = state.blender;
const configWithCalibration = {
...mocapTaskConfig,
calibrationTomlPath: calibrationTomlPath,
+ exportToBlender: blender.exportToBlenderEnabled,
+ blenderExePath: blender.blenderExePath ?? blender.detectedBlenderExePath,
+ autoOpenBlendFile: blender.autoOpenBlendFile,
};
console.log('🎬 Starting mocap recording with:', {
@@ -69,9 +73,13 @@ export const stopMocapRecording = createAsyncThunk<
const calibrationTomlPath = state.mocap.calibrationTomlPath;
+ const blender = state.blender;
const configWithCalibration = {
...mocapTaskConfig,
calibrationTomlPath: calibrationTomlPath,
+ exportToBlender: blender.exportToBlenderEnabled,
+ blenderExePath: blender.blenderExePath ?? blender.detectedBlenderExePath,
+ autoOpenBlendFile: blender.autoOpenBlendFile,
};
console.log(`🎬 Stopping mocap recording and starting mocap with: ${JSON.stringify(configWithCalibration, null, 2)}`);
@@ -120,9 +128,13 @@ export const processMocapRecording = createAsyncThunk<
});
const calibrationTomlPath = state.mocap.calibrationTomlPath;
+ const blender = state.blender;
const configWithCalibration = {
...mocapTaskConfig,
calibrationTomlPath: calibrationTomlPath,
+ exportToBlender: blender.exportToBlenderEnabled,
+ blenderExePath: blender.blenderExePath ?? blender.detectedBlenderExePath,
+ autoOpenBlendFile: blender.autoOpenBlendFile,
};
const response = await fetch(serverUrls.endpoints.processMocapRecording, {
diff --git a/freemocap-ui/src/store/store.ts b/freemocap-ui/src/store/store.ts
index e54ef0a2..0ad0fcee 100644
--- a/freemocap-ui/src/store/store.ts
+++ b/freemocap-ui/src/store/store.ts
@@ -8,6 +8,7 @@ import {calibrationSlice} from "@/store/slices/calibration/calibration-slice";
import {mocapSlice} from "@/store/slices/mocap/mocap-slice";
import {localeSlice} from "@/store/slices/locale";
import {pipelinesSlice} from "@/store/slices/pipelines/pipelines-slice";
+import {blenderSlice} from "@/store/slices/blender/blender-slice";
export const store = configureStore({
reducer: {
@@ -20,5 +21,6 @@ export const store = configureStore({
mocap: mocapSlice.reducer,
locale: localeSlice.reducer,
pipelines: pipelinesSlice.reducer,
+ blender: blenderSlice.reducer,
},
});
diff --git a/freemocap/api/http/blender/blender_router.py b/freemocap/api/http/blender/blender_router.py
index 76bcb6b7..fe9a3d1f 100644
--- a/freemocap/api/http/blender/blender_router.py
+++ b/freemocap/api/http/blender/blender_router.py
@@ -45,14 +45,16 @@ class ExportToBlenderRequest(BaseModel):
"example": {
"recordingFolderPath": FREEMOCAP_TEST_DATA_PATH,
"blenderExePath": None,
+ "autoOpenBlendFile": True,
}
},
)
recording_folder_path: str = Field(alias="recordingFolderPath", default=FREEMOCAP_TEST_DATA_PATH)
blender_exe_path: str | None = Field(alias="blenderExePath", default=None, examples=[None])
+ auto_open_blend_file: bool = Field(alias="autoOpenBlendFile", default=True)
@property
- def blender_file_path(self):
+ def blend_file_path(self):
recording_name = Path(self.recording_folder_path).stem
return str(Path(self.recording_folder_path) /f"{recording_name}.blend")
@@ -128,13 +130,14 @@ def export_to_blender_endpoint(request: ExportToBlenderRequest) -> ExportToBlend
export_to_blender(
recording_folder_path=str(recording_folder),
- blender_file_path=request.blender_file_path,
+ blend_file_path=request.blend_file_path,
blender_exe_path=str(blender_exe),
+ open_file_on_completion=request.auto_open_blend_file,
)
return ExportToBlenderResponse(
success=True,
message="Export to Blender completed",
- blender_file_path=request.blender_file_path,
+ blender_file_path=request.blend_file_path,
)
except HTTPException:
raise
diff --git a/freemocap/api/http/mocap/mocap_router.py b/freemocap/api/http/mocap/mocap_router.py
index 70137294..3903afba 100644
--- a/freemocap/api/http/mocap/mocap_router.py
+++ b/freemocap/api/http/mocap/mocap_router.py
@@ -53,9 +53,15 @@ def _process_mocap_request_schema_extra(schema: dict) -> None:
class ProcessMocapRecordingRequest(BaseModel):
- model_config = ConfigDict(json_schema_extra=_process_mocap_request_schema_extra)
- mocap_recording_directory: str = Field(default=FREEMOCAP_TEST_DATA_PATH)
- mocap_config: PosthocMocapPipelineConfig = Field(default_factory=PosthocMocapPipelineConfig)
+ model_config = ConfigDict(
+ populate_by_name=True,
+ json_schema_extra=_process_mocap_request_schema_extra,
+ )
+ mocap_recording_directory: str = Field(alias="mocapRecordingDirectory")
+ mocap_config: PosthocMocapPipelineConfig = Field(
+ alias="mocapTaskConfig",
+ default_factory=PosthocMocapPipelineConfig,
+ )
@classmethod
def create_test_data_request(cls) -> "ProcessMocapRecordingRequest":
diff --git a/freemocap/core/blender/export_to_blender.py b/freemocap/core/blender/export_to_blender.py
index 68246c53..cd1f6989 100644
--- a/freemocap/core/blender/export_to_blender.py
+++ b/freemocap/core/blender/export_to_blender.py
@@ -6,6 +6,7 @@ from typing import Union, List
import freemocap_blender_addon
+from freemocap.core.blender.helpers import run_blender_export as run_blender_export_module
from freemocap.core.blender.helpers.run_blender_export import run_blender_export
from freemocap.core.blender.helpers.get_best_guess_of_blender_path import get_best_guess_of_blender_path
from freemocap.utilities.open_file import open_file
@@ -37,7 +38,7 @@ OLD_SEGMENT_CENTER_OF_MASS_NPY_FILE_NAME = "segmentCOM_frame_joint_xyz.npy"
def run_subprocess(command_list: List[str]):
logger.debug(f"Running subprocess with command list: {command_list}")
- process = subprocess.Popen(command_list, shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ process = subprocess.Popen(command_list, shell=False, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
return process
@@ -66,7 +67,9 @@ def export_to_blender(
site_packages_path = str(addon_package_path.parent.parent)
logger.debug(f"Will inject site-packages path into Blender's sys.path: {site_packages_path}")
- simple_run_script = inspect.getfile(run_blender_export)
+ # Use the module's __file__ directly — inspect.getfile() on a @beartype-wrapped
+ # function returns repr() of the wrapper, not the source file path.
+ simple_run_script = run_blender_export_module.__file__
command_list = [
str(blender_exe_path),
@@ -91,7 +94,7 @@ def export_to_blender(
logging.debug(output.strip().decode())
if blender_process.returncode != 0:
- logging.error(blender_process.stderr.read().decode())
+ logging.error(f"Blender subprocess exited with non-zero return code: {blender_process.returncode}")
if not Path(blend_file_path).is_file():
raise RuntimeError(f"Blender output file not found at: {blend_file_path}")
elif Path(blend_file_path).stat().st_size == 0:
diff --git a/freemocap/core/blender/helpers/run_blender_export.py b/freemocap/core/blender/helpers/run_blender_export.py
index c3d50ed0..2642529c 100644
--- a/freemocap/core/blender/helpers/run_blender_export.py
+++ b/freemocap/core/blender/helpers/run_blender_export.py
@@ -1,4 +1,5 @@
import sys
+import traceback
def run_blender_export(site_packages_path: str, recording_path_input: str, blender_file_save_path_input: str):
@@ -7,22 +8,39 @@ def run_blender_export(site_packages_path: str, recording_path_input: str, blend
if site_packages_path not in sys.path:
sys.path.insert(0, site_packages_path)
+ # Blender's addons directory may contain a stale/broken `freemocap_blender_addon`
+ # that Blender preloads as a namespace package, hijacking the name and causing
+ # `from freemocap_blender_addon.main import ...` to fail silently. Evict any
+ # preloaded copy and strip the addons path so our venv copy wins the import.
+ for mod_name in [m for m in list(sys.modules) if m == "freemocap_blender_addon" or m.startswith("freemocap_blender_addon.")]:
+ print(f"Evicting preloaded module from sys.modules: {mod_name}")
+ del sys.modules[mod_name]
+ sys.path[:] = [p for p in sys.path if "Blender Foundation" not in p or "addons" not in p.replace("\\", "/")]
+
+ print(f"sys.path[0:3] = {sys.path[0:3]}")
from freemocap_blender_addon.main import ajc27_run_as_main_function
+ print(f"Imported ajc27_run_as_main_function from: {ajc27_run_as_main_function.__module__}")
ajc27_run_as_main_function(recording_path=str(recording_path_input),
blend_file_path=str(blender_file_save_path_input))
if __name__ == "__main__":
- print(f"\nRunning {__file__} as a subprocess...\n")
- argv = sys.argv
- print(f"Received command line arguments: {argv}")
- argv = argv[argv.index("--") + 1:]
- site_packages_path_input = str(argv[0])
- recording_path_input = str(argv[1])
- blender_file_save_path_input = str(argv[2])
- run_blender_export(site_packages_path=site_packages_path_input,
- recording_path_input=recording_path_input,
- blender_file_save_path_input=blender_file_save_path_input)
-
- print("\nDone!\n")
+ try:
+ print(f"\nRunning {__file__} as a subprocess...\n", flush=True)
+ argv = sys.argv
+ print(f"Received command line arguments: {argv}", flush=True)
+ argv = argv[argv.index("--") + 1:]
+ site_packages_path_input = str(argv[0])
+ recording_path_input = str(argv[1])
+ blender_file_save_path_input = str(argv[2])
+ run_blender_export(site_packages_path=site_packages_path_input,
+ recording_path_input=recording_path_input,
+ blender_file_save_path_input=blender_file_save_path_input)
+
+ print("\nDone!\n", flush=True)
+ except Exception:
+ print("\n!!! Blender export script FAILED with exception:\n", flush=True)
+ traceback.print_exc()
+ sys.stderr.flush()
+ sys.exit(1)
diff --git a/freemocap/core/pipeline/realtime/camera_node_config.py b/freemocap/core/pipeline/realtime/camera_node_config.py
index 89f84b23..80d6ae37 100644
--- a/freemocap/core/pipeline/realtime/camera_node_config.py
+++ b/freemocap/core/pipeline/realtime/camera_node_config.py
@@ -9,7 +9,7 @@ class CameraNodeConfig(BaseModel):
skeleton_tracking_enabled: bool = True
charuco_detector_config: CharucoDetectorConfig|None = Field(default_factory=CharucoDetectorConfig)
skeleton_detector_config: SkeletonDetectorConfig|None = Field(default_factory=lambda: RTMPoseDetectorConfig(mode="lightweight",
- confidence_threshold=4))
+ confidence_threshold=5))
# skeleton_detector_config: LegacyMediapipeDetectorConfig|None = Field(default_factory=LegacyMediapipeDetectorConfig)
@property
diff --git a/freemocap/core/tasks/mocap/mocap_task_config.py b/freemocap/core/tasks/mocap/mocap_task_config.py
index a3aa75ec..6d73a649 100644
--- a/freemocap/core/tasks/mocap/mocap_task_config.py
+++ b/freemocap/core/tasks/mocap/mocap_task_config.py
@@ -1,6 +1,7 @@
from pydantic import BaseModel, ConfigDict, Field
from skellytracker.trackers.base_tracker.detector_helpers import SkeletonDetectorConfig
from skellytracker.trackers.rtmpose_tracker.rtmpose_detector import RTMPoseDetectorConfig
+from skellytracker.trackers.mediapipe_tracker import MediapipeDetectorConfig
from freemocap.core.tasks.calibration.calibration_task_config import CalibrationSource
@@ -10,7 +11,7 @@ from freemocap.core.tasks.calibration.calibration_task_config import Calibration
class PosthocMocapPipelineConfig(BaseModel):
model_config = ConfigDict(populate_by_name=True)
- skeleton_detector_config: SkeletonDetectorConfig = Field(default_factory= RTMPoseDetectorConfig)#LegacyMediapipeDetectorConfig)
+ skeleton_detector_config: SkeletonDetectorConfig = Field(default_factory= MediapipeDetectorConfig)#LegacyMediapipeDetectorConfig)
calibration_source: CalibrationSource = Field(
default=CalibrationSource.MOST_RECENT,
alias="calibrationSource",
@@ -21,6 +22,21 @@ class PosthocMocapPipelineConfig(BaseModel):
alias="calibrationTomlPath",
description="Path to calibration TOML. Only used when calibration_source is 'specified'.",
)
+ export_to_blender: bool = Field(
+ default=True,
+ alias="exportToBlender",
+ description="If True, export the processed mocap recording to a .blend file after processing.",
+ )
+ blender_exe_path: str | None = Field(
+ default=None,
+ alias="blenderExePath",
+ description="Path to the Blender executable. If None, auto-detect.",
+ )
+ auto_open_blend_file: bool = Field(
+ default=True,
+ alias="autoOpenBlendFile",
+ description="If True, open the .blend file in Blender after export completes.",
+ )
@classmethod
diff --git a/freemocap/core/tasks/mocap/posthoc_mocap_task.py b/freemocap/core/tasks/mocap/posthoc_mocap_task.py
index a8a684b4..07a72ba5 100644
--- a/freemocap/core/tasks/mocap/posthoc_mocap_task.py
+++ b/freemocap/core/tasks/mocap/posthoc_mocap_task.py
@@ -31,7 +31,7 @@ from freemocap.core.tasks.mocap.mocap_helpers.skeleton_from_mediapipe_observatio
skeleton_from_mediapipe_observation_recorders
from freemocap.core.pipeline.posthoc.video_group_helper import VideoMetadata
from freemocap.core.types.type_overloads import VideoIdString
-
+from skellytracker.trackers.mediapipe_tracker import MediapipeObservation
logger = logging.getLogger(__name__)
@@ -41,7 +41,6 @@ def run_posthoc_mocap_aggregator_task(
recording_info: RecordingInfo,
video_metadata: dict[VideoIdString, VideoMetadata],
task_config: PosthocMocapPipelineConfig,
- create_blender_output: bool=True, #TODO - Add this to the mocap config, after we split the RT and PH pipeline
report_progress: Callable[[str, float], None] | None = None,
) -> None:
@@ -67,8 +66,7 @@ def run_posthoc_mocap_aggregator_task(
for frame_idx, frame_obs in enumerate(frame_observations):
for vid_id, obs in frame_obs.items():
- if not isinstance(obs, RTMPoseObservation) and not isinstance(obs, RTMPoseObservation):
- # if not isinstance(obs, MediapipeObservation) and not isinstance(obs, LegacyMediapipeObservation):
+ if not isinstance(obs, RTMPoseObservation) and not isinstance(obs, MediapipeObservation):
raise TypeError(
f"Expected MediapipeObservation for video {vid_id} frame {frame_idx}, "
f"got {type(obs).__name__}"
@@ -115,11 +113,17 @@ def run_posthoc_mocap_aggregator_task(
- if create_blender_output:
-
- export_to_blender(
- recording_folder_path=str(recording_info.full_recording_path),
- )
+ if task_config.export_to_blender:
+ try:
+ export_to_blender(
+ recording_folder_path=str(recording_info.full_recording_path),
+ blender_exe_path=task_config.blender_exe_path,
+ open_file_on_completion=task_config.auto_open_blend_file,
+ )
+ except Exception as e:
+ # Don't crash the whole aggregator if blender export fails —
+ # mocap outputs are already saved; blender is an optional post-step.
+ logger.exception(f"Blender export failed (mocap data still saved): {e}")
if report_progress is not None:
report_progress("Mocap complete", 1.0)
logger.info(
diff --git a/uv.lock b/uv.lock
index 5cb52eb5..5b21c93c 100644
--- a/uv.lock
+++ b/uv.lock
@@ -587,7 +587,7 @@ dev = [
[[package]]
name = "freemocap-blender-addon"
version = "2025.11.1038"
-source = { git = "https://github.com/freemocap/freemocap_blender_addon?branch=development#e5aab4908f9d4caae7067aa31e8e685a6201b036" }
+source = { git = "https://github.com/freemocap/freemocap_blender_addon?branch=development#66fd590e8c3c0f3b75a2da06a7ae8dfba96fe254" }
[[package]]
name = "h11"