Skip to content

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

TypeScript

MULTI STUFF

Endurance Idehen91d1dda798a8
diff --git a/freemocap/prod/cam/detection/cam_detection.py b/freemocap/prod/cam/detection/cam_detection.py
index a0e125dd..2db7154b 100644
--- a/freemocap/prod/cam/detection/cam_detection.py
+++ b/freemocap/prod/cam/detection/cam_detection.py
@@ -27,6 +27,7 @@ class DetectPossibleCameras:
finally:
cap.release()
+ print(cams_to_use_list)
return FindAvailableResponse(
camera_found_count=len(cams_to_use_list),
cams_to_use=cams_to_use_list,
diff --git a/jon_scratch/opencv_camera.py b/jon_scratch/opencv_camera.py
index 4ca36d5c..23714a08 100644
--- a/jon_scratch/opencv_camera.py
+++ b/jon_scratch/opencv_camera.py
@@ -26,7 +26,7 @@ class TweakedModel(BaseModel):
# OpenCV Implementation of interacting with a camera
class OpenCVCamera(TweakedModel):
port_number: int = 0
- name: str = f'Camera{port_number}'
+ name: str = f'Camera {port_number}'
# exposure: int = 0
exposure: int = -6
resolution_width: int = 800
@@ -63,10 +63,9 @@ class OpenCVCamera(TweakedModel):
return success
def get_next_frame(self):
-
timestamp_ns_pre_grab = time.time_ns()
- # Why grab not read? see -> https://stackoverflow.com/questions/57716962/difference
- # -between-video-capture-read-and-grab
+ # Why grab not read? see ->
+ # https://stackoverflow.com/questions/57716962/difference-between-video-capture-read-and-grab
grab_success = self.opencv_video_capture_object.grab()
timestamp_ns_post_grab = time.time_ns()
timestamp_ns = (timestamp_ns_pre_grab + timestamp_ns_post_grab) / 2
diff --git a/src/api/routes/camera/cam_data_ws.py b/src/api/routes/camera/cam_data_ws.py
index bca8b1a4..b80df51f 100644
--- a/src/api/routes/camera/cam_data_ws.py
+++ b/src/api/routes/camera/cam_data_ws.py
@@ -1,6 +1,7 @@
import logging
from time import perf_counter
+import aiomultiprocess
import orjson
from fastapi import APIRouter, WebSocket
diff --git a/src/api/routes/startup/startup.py b/src/api/routes/startup/startup.py
index 750fb0de..5e246616 100644
--- a/src/api/routes/startup/startup.py
+++ b/src/api/routes/startup/startup.py
@@ -1,3 +1,4 @@
+import aiomultiprocess
from fastapi import APIRouter
from freemocap.prod.cam.detection.cam_singleton import get_or_create_cams
@@ -7,4 +8,5 @@ startup_router = APIRouter()
@startup_router.on_event('startup')
async def handle_startup():
- get_or_create_cams()
+ aiomultiprocess.set_start_method("spawn")
+ # get_or_create_cams()
diff --git a/src/api/services/board_detect_service.py b/src/api/services/board_detect_service.py
index b5324fa0..da5bfaef 100644
--- a/src/api/services/board_detect_service.py
+++ b/src/api/services/board_detect_service.py
@@ -1,24 +1,18 @@
import asyncio
-from freemocap.prod.cam.detection.cam_singleton import get_or_create_cams
-from src.core_processor.app_events.app_queue import AppQueue
+from aiomultiprocess.core import get_manager
+
from src.core_processor.board_detection.detect import BoardDetection
-from src.core_processor.processor import capture_cam_images_new_process
+from src.core_processor.processor import start_camera_capture
class BoardDetectService:
async def run(self):
- cams = get_or_create_cams()
- webcam_ids = [
- rawCam.port_number for rawCam in cams.cams_to_use
- ]
- app_queue = AppQueue()
- app_queue.create_all(webcam_ids)
- queues = app_queue.queues
+ queue = get_manager().Queue()
await asyncio.gather(
# Producer
- capture_cam_images_new_process(queues),
+ start_camera_capture(queue),
# Consumer
- BoardDetection().create_new_process_for_run(queues)
+ BoardDetection().create_new_process_for_run(queue)
)
diff --git a/src/core_processor/board_detection/detect.py b/src/core_processor/board_detection/detect.py
index 0a69bd1b..a7b2da30 100644
--- a/src/core_processor/board_detection/detect.py
+++ b/src/core_processor/board_detection/detect.py
@@ -1,30 +1,31 @@
import logging
-from typing import Dict
import cv2
from aiomultiprocess import Process
+from aiomultiprocess.types import Queue
-from src.core_processor.app_events.app_queue import CameraFrameQueue
+from src.core_processor.processor import ImagePayload
logger = logging.getLogger(__name__)
class BoardDetection:
- async def create_new_process_for_run(self, queues: Dict[str, CameraFrameQueue]):
- p = Process(target=self.process, args=(queues,))
+ async def create_new_process_for_run(self, queue: Queue):
+ p = Process(target=self.process, args=(queue,))
p.start()
await p.join()
- async def process(self, queues: Dict[str, CameraFrameQueue]):
+ async def process(self, queue: Queue):
while True:
- for webcam_id in queues:
- queue = queues[webcam_id].queue
- try:
- image, timestamp = queue.get(timeout=.01)
- cv2.imshow(webcam_id, image)
+ try:
+ message = queue.get(timeout=1) # type: ImagePayload
+ frames = message.frames
+ for f in frames:
+ cv2.imshow(str(f.port_number), f.image)
exit_key = cv2.waitKey(1)
if exit_key == 27:
break
- except:
- pass
+ except Exception as e:
+ print(e)
+ logger.error(e)
diff --git a/src/core_processor/processor.py b/src/core_processor/processor.py
index 9e3af2e5..0a9a2c53 100644
--- a/src/core_processor/processor.py
+++ b/src/core_processor/processor.py
@@ -1,8 +1,9 @@
import logging
-import time
-from typing import Dict
+from typing import Dict, List, NamedTuple
+import numpy as np
from aiomultiprocess import Process
+from aiomultiprocess.types import Queue
from freemocap.prod.cam.detection.cam_singleton import get_or_create_cams
from jon_scratch.opencv_camera import OpenCVCamera
@@ -21,27 +22,49 @@ def create_opencv_cams():
return cv_cams
-async def capture_cam_images_new_process(queue):
- p = Process(target=_start_camera_capture, args=(queue,))
- p.start()
- await p.join()
-
-
-async def _start_camera_capture(queues: Dict[str, CameraFrameQueue]):
- cv_cams = create_opencv_cams()
- logger = logging.getLogger(__name__)
- # threading could be added here!
- while True:
- for cv_cam in cv_cams:
- webcam_id = str(cv_cam.port_number)
- queue = queues[webcam_id].queue
- t1_start = time.perf_counter()
- success, image, timestamp = cv_cam.get_next_frame()
- if not success:
- continue
- if image is None:
- continue
- queue.put_nowait((image, timestamp))
- t1_stop = time.perf_counter()
- logger.info(f"Elapsed time per insert into queue: {t1_stop - t1_start}")
+async def start_camera_capture(queue: Queue):
+ processes = []
+ creator = CameraCaptureProcess()
+ process = Process(
+ target=creator.run,
+ args=(queue,)
+ )
+ process.start()
+ processes.append(process)
+
+class FramePayload(NamedTuple):
+ port_number: int
+ image: np.ndarray
+ timestamp: int
+
+
+class ImagePayload(NamedTuple):
+ frames: List[FramePayload]
+
+
+class CameraCaptureProcess:
+ async def run(self, queue):
+ cv_cams = create_opencv_cams()
+ _queue = queue
+ _logger = logging.getLogger(__name__)
+
+ while True:
+ image_list: List[FramePayload] = []
+ for cv_cam in cv_cams:
+ success, image, timestamp = cv_cam.get_next_frame()
+ if not success:
+ continue
+ if image is None:
+ continue
+ image_list.append(
+ FramePayload(
+ port_number=cv_cam.port_number,
+ image=image,
+ timestamp=timestamp
+ )
+ )
+ _queue.put(
+ ImagePayload(frames=image_list)
+ )
+ # _logger.info("Im printing stuff")