Skip to content

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

TypeScript

building the processing server

jonmatthis2e8f3cb7456b
diff --git a/freemocap/api/websocket/websocket_server.py b/freemocap/api/websocket/websocket_server.py
index b82b7ac4..778bddeb 100644
--- a/freemocap/api/websocket/websocket_server.py
+++ b/freemocap/api/websocket/websocket_server.py
@@ -12,6 +12,7 @@ from skellycam.utilities.wait_functions import async_wait_1ms
from starlette.websockets import WebSocket, WebSocketState, WebSocketDisconnect
from freemocap.freemocap_app.freemocap_app_state import get_freemocap_app_state, FreemocapAppState
+from freemocap.pipelines.pipeline_abcs import FreemocapProcessingServer
logger = logging.getLogger(__name__)
@@ -91,6 +92,7 @@ class FreemocapWebsocketServer:
camera_group_uuid = None
latest_mf_number = -1
+ processing_server: Optional[FreemocapProcessingServer] = None #Starts when camera group is detected, should probably be handled differently but this works fn
try:
while True:
await async_wait_1ms()
@@ -108,7 +110,9 @@ class FreemocapWebsocketServer:
if self._freemocap_app_state.skellycam_app_state.camera_group and camera_group_uuid != self._freemocap_app_state.skellycam_app_state.camera_group.uuid:
latest_mf_number = -1
camera_group_uuid = self._freemocap_app_state.skellycam_app_state.camera_group.uuid
- image_processing_shms_by_camera = self._freemocap_app_state.create_image_processing_shms_by_camera()
+ if processing_server:
+ processing_server.shutdown()
+ processing_server = self._freemocap_app_state.create_processing_server()
continue
if not self._freemocap_app_state.skellycam_app_state.frame_escape_shm.latest_mf_number.value > latest_mf_number:
@@ -118,7 +122,8 @@ class FreemocapWebsocketServer:
camera_configs=self._freemocap_app_state.skellycam_app_state.camera_group.camera_configs,
retrieve_type="latest")
await self._send_frontend_payload(mf_payload)
-
+ if processing_server:
+ processing_server.process_image_payload(mf_payload)
latest_mf_number = mf_payload.multi_frame_number
except WebSocketDisconnect:
diff --git a/freemocap/freemocap_app/freemocap_app_state.py b/freemocap/freemocap_app/freemocap_app_state.py
index b4c7718e..22974d04 100644
--- a/freemocap/freemocap_app/freemocap_app_state.py
+++ b/freemocap/freemocap_app/freemocap_app_state.py
@@ -17,7 +17,7 @@ logger = logging.getLogger(__name__)
class FreemocapAppState:
global_kill_flag: multiprocessing.Value
skellycam_app_state: SkellycamAppState
- processing_server: ProcessingServer|None = None
+
@classmethod
def create(cls, global_kill_flag: multiprocessing.Value):
create_skellycam_app_controller(global_kill_flag=global_kill_flag)
@@ -37,7 +37,7 @@ class FreemocapAppState:
def skellycam_ipc_queue(self):
return self.skellycam_app_state.ipc_queue
- def create_image_processing_server(self, processing_server: FreemocapProcessingServer):
+ def create_processing_server(self) -> FreemocapProcessingServer:
if not self.frame_escape_shm:
raise ValueError("Cannot create image processing server without frame escape shared memory!")
return FreemocapProcessingServer.create(skellycam_app_state=self.skellycam_app_state)
diff --git a/freemocap/pipelines/pipeline_abcs.py b/freemocap/pipelines/pipeline_abcs.py
index cbf0d3c4..5686afc2 100644
--- a/freemocap/pipelines/pipeline_abcs.py
+++ b/freemocap/pipelines/pipeline_abcs.py
@@ -1,13 +1,14 @@
import logging
+import multiprocessing
from abc import ABC, abstractmethod
from multiprocessing import Process, Queue
from typing import Dict, OrderedDict
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, ConfigDict
from skellycam.core import CameraId
from skellycam.core.camera_group.shmorchestrator.shared_memory.ring_buffer_camera_shared_memory import \
RingBufferCameraSharedMemory
-from skellycam.core.camera_group.shmorchestrator.shared_memory.ring_buffer_shared_memory import SharedMemoryRingBuffer, \
+from skellycam.core.camera_group.shmorchestrator.shared_memory.ring_buffer_shared_memory import \
SharedMemoryRingBufferDTO
from skellycam.skellycam_app.skellycam_app_state import SkellycamAppState
@@ -15,19 +16,23 @@ logger = logging.getLogger(__name__)
class PipelineStageConfig(BaseModel, ABC):
+ model_config = ConfigDict(arbitrary_types_allowed=True)
pass
class PipelineConfig(BaseModel, ABC):
- stage_configs: Dict[str, PipelineStageConfig]
+ model_config = ConfigDict(arbitrary_types_allowed=True)
+ stage_configs: Dict[str, PipelineStageConfig] = Field(default_factory=dict)
class PipelineData(BaseModel, ABC):
+ model_config = ConfigDict(arbitrary_types_allowed=True)
data: object
metadata: dict[object, object] = Field(default_factory=dict)
class PipelineStage(BaseModel, ABC):
+ model_config = ConfigDict(arbitrary_types_allowed=True)
config: PipelineConfig
@abstractmethod
@@ -36,6 +41,7 @@ class PipelineStage(BaseModel, ABC):
class PipelineModel(BaseModel, ABC):
+ model_config = ConfigDict(arbitrary_types_allowed=True)
config: PipelineConfig
stages: OrderedDict[str, PipelineStage]
@@ -49,8 +55,8 @@ class PipelineModel(BaseModel, ABC):
class CameraProcessingNode(BaseModel, ABC):
+ model_config = ConfigDict(arbitrary_types_allowed=True)
camera_id: CameraId
- image_ring_shm: SharedMemoryRingBuffer
process: Process
output_queue: Queue
config: PipelineConfig
@@ -60,13 +66,10 @@ class CameraProcessingNode(BaseModel, ABC):
config: PipelineConfig,
camera_id: CameraId,
camera_ring_shm_dto: SharedMemoryRingBufferDTO,
- input_queue: Queue,
- output_queue: Queue):
+ output_queue: Queue,
+ shutdown_event: multiprocessing.Event):
return cls(camera_id=camera_id,
- image_ring_shm=SharedMemoryRingBuffer.recreate(camera_ring_shm_dto,
- read_only=True),
- input_queue=input_queue,
- output_queue=output_queue,
+ process=Process(target=cls._run, args=(config, camera_ring_shm_dto, output_queue)),
config=config)
def start(self):
@@ -78,18 +81,30 @@ class CameraProcessingNode(BaseModel, ABC):
def join(self):
self.process.join()
+ @staticmethod
+ def _run(config: PipelineConfig, camera_ring_shm_dto: SharedMemoryRingBufferDTO, output_queue: Queue):
+ pass
+
class AggregationProcessNode(BaseModel, ABC):
+ model_config = ConfigDict(arbitrary_types_allowed=True)
config: PipelineConfig
process: Process
input_queues: Dict[CameraId, Queue]
output_queue: Queue
+ shutdown_event: multiprocessing.Event
@classmethod
- def create(cls, config: PipelineConfig, input_queues: Dict[CameraId, Queue], output_queue: Queue):
+ def create(cls,
+ config: PipelineConfig,
+ input_queues: Dict[CameraId, Queue],
+ output_queue: Queue,
+ shutdown_event: multiprocessing.Event):
return cls(config=config,
+ process=Process(target=cls._run, args=(config, input_queues, output_queue, shutdown_event)),
input_queues=input_queues,
- output_queue=output_queue)
+ output_queue=output_queue,
+ shutdown_event=shutdown_event)
def start(self):
self.process.start()
@@ -100,58 +115,116 @@ class AggregationProcessNode(BaseModel, ABC):
def join(self):
self.process.join()
+ @staticmethod
+ def _run(config: PipelineConfig, input_queues: Dict[CameraId, Queue], output_queue: Queue,
+ shutdown_event: multiprocessing.Event):
+ pass
+
-class CameraGroupProcessingTree(ABC):
+class CameraGroupProcessingPipeline(BaseModel, ABC):
+ model_config = ConfigDict(arbitrary_types_allowed=True)
camera_processes: Dict[CameraId, CameraProcessingNode]
aggregation_process: Process
queues_by_camera_id: Dict[CameraId, Queue]
output_queue: Queue
+ shutdown_event: multiprocessing.Event
@classmethod
def create(cls, *args, **kwargs):
pass
+ def start(self):
+ self.aggregation_process.start()
+ for camera_id, camera_process in self.camera_processes.items():
+ camera_process.start()
+
+ def shutdown(self):
+ self.shutdown_event.set()
+ self.aggregation_process.join()
+ for camera_id, camera_process in self.camera_processes.items():
+ camera_process.join()
+
+ def intake_data(self, data: PipelineData):
+ for camera_id, camera_process in self.camera_processes.items():
+ camera_process.intake_data(data)
+
class CameraGroupProcessingServer(BaseModel, ABC):
- process_tree: CameraGroupProcessingTree
+ model_config = ConfigDict(arbitrary_types_allowed=True)
+ processing_pipeline: CameraGroupProcessingPipeline
+ shutdown_event: multiprocessing.Event
- def process_data(self, data: PipelineData) -> PipelineData:
- return self.pipeline.process_data(data)
+ def intake_data(self, data: PipelineData):
+ self.processing_pipeline.intake_data(data)
+
+ def start(self):
+ self.processing_pipeline.start()
+
+ def shutdown(self):
+ self.shutdown_event.set()
+ self.processing_pipeline.shutdown()
+class FreemocapCameraProcessingNode(CameraProcessingNode):
+ @staticmethod
+ def _run(config: PipelineConfig, camera_ring_shm_dto: SharedMemoryRingBufferDTO, output_queue: Queue):
+ pass
-class FreeMoCapProcessingTree(CameraGroupProcessingTree):
+class FreemocapAggregationProcessNode(AggregationProcessNode):
+ @staticmethod
+ def _run(config: PipelineConfig, input_queues: Dict[CameraId, Queue], output_queue: Queue,
+ shutdown_event: multiprocessing.Event):
+ pass
+
+class FreemocapPipelineConfig(PipelineConfig):
+ pass
+
+class FreemocapProcessingPipeline(CameraGroupProcessingPipeline):
camera_ring_buffer_shms: Dict[CameraId, RingBufferCameraSharedMemory]
+ shutdown_event: multiprocessing.Event
@classmethod
def create(cls,
skellycam_app_state: SkellycamAppState,
- pipeline_config: PipelineConfig = PipelineConfig()):
+ shutdown_event: multiprocessing.Event,
+ pipeline_config: FreemocapPipelineConfig = FreemocapPipelineConfig()):
+ if skellycam_app_state.camera_ring_buffer_shms is None:
+ raise ValueError("Cannot create FreeMoCapProcessingTree without camera ring buffer SHMs!")
camera_ring_buffer_shms = skellycam_app_state.camera_ring_buffer_shms
camera_processes = {}
queues_by_camera_id = {}
output_queue = Queue()
for camera_id, camera_shm in camera_ring_buffer_shms.items():
camera_shm_dto = camera_shm.to_dto()
- input_queue = Queue()
+ camera_output_queue = Queue()
camera_processes[camera_id] = CameraProcessingNode.create(config=pipeline_config,
camera_id=camera_id,
camera_ring_shm_dto=camera_shm_dto,
- input_queue=input_queue,
- output_queue=output_queue)
- queues_by_camera_id[camera_id] = input_queue
+ output_queue=camera_output_queue,
+ shutdown_event=shutdown_event,
+ )
+ queues_by_camera_id[camera_id] = camera_output_queue
aggregation_process = AggregationProcessNode.create(config=PipelineConfig(),
input_queues=queues_by_camera_id,
- output_queue=Queue())
+ output_queue=output_queue,
+ shutdown_event=shutdown_event,
+ )
return cls(camera_processes=camera_processes,
camera_ring_buffer_shms=camera_ring_buffer_shms,
aggregation_process=aggregation_process,
queues_by_camera_id=queues_by_camera_id,
- output_queue=aggregation_process.output_queue)
+ output_queue=aggregation_process.output_queue,
+ shutdown_event=shutdown_event,
+ )
class FreemocapProcessingServer(CameraGroupProcessingServer):
@classmethod
- def create(cls, skellycam_app_state: SkellycamAppState):
- return cls(process_tree=CameraGroupProcessingTree.create(skellycam_app_state))
+ def create(cls,
+ skellycam_app_state: SkellycamAppState):
+ shutdown_event = multiprocessing.Event()
+ return cls(processing_pipeline=FreemocapProcessingPipeline.create(skellycam_app_state=skellycam_app_state,
+ shutdown_event=shutdown_event),
+ shutdown_event=shutdown_event,
+ )
diff --git a/uv.lock b/uv.lock
index 617edfd3..997d1812 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1531,7 +1531,7 @@ dependencies = [
[[package]]
name = "skellycam"
version = "2023.9.1086"
-source = { git = "https://github.com/freemocap/skellycam?branch=jon%2Fdevelopment#7c303bd2e64c06d86c79b1e7330a96a7f56fe3ff" }
+source = { git = "https://github.com/freemocap/skellycam?branch=jon%2Fdevelopment#9ca828a339dd814378d7daa6fcccd9969a4cf9be" }
dependencies = [
{ name = "fastapi" },
{ name = "httpx" },