uncoupled webcam.py for simplified requirements.txt

Author: JensBlack

DeepLabStream.py

@@ -17,7 +17,8 @@
 import numpy as np
 import pandas as pd
 
-from utils.generic import VideoManager, WebCamManager, GenericManager
+from utils.generic import VideoManager, GenericManager
+
 from utils.configloader import RESOLUTION, FRAMERATE, OUT_DIR, MODEL_NAME, MULTI_CAM, STACK_FRAMES, \
     ANIMALS_NUMBER, FLATTEN_MA, STREAMS, STREAMING_SOURCE, MODEL_ORIGIN, CROP, CROP_X, CROP_Y
 from utils.plotter import plot_bodyparts,plot_metadata_frame
@@ -145,6 +146,7 @@ def select_camera_manager():
                 pylon_manager = PylonManager()
                 manager_list.append(pylon_manager)
 
+
             def check_for_cameras(camera_manager):
                 """
                 Helper method to get cameras, connected to that camera manager
@@ -167,17 +169,21 @@ def check_for_cameras(camera_manager):
 
         MANAGER_SOURCE = {
             'video': VideoManager,
-            'ipwebcam': WebCamManager,
             'camera': select_camera_manager
         }
 
+        # loading WebCam manager, if installed
+        if find_spec("pyzmq") is not None:
+            from utils.webcam import WebCamManager
+            MANAGER_SOURCE['ipwebcam'] = WebCamManager()
+
         # initialize selected manager
         camera_manager = MANAGER_SOURCE.get(STREAMING_SOURCE)()
         if camera_manager is not None:
             return camera_manager
         else:
             raise ValueError(f'Streaming source {STREAMING_SOURCE} is not a valid option. \n'
-                             f'Please choose from "video", "camera" or "ipwebcam".')
+                             f'Please choose from "video", "camera" or "ipwebcam". Make sure that if you are using "ipwebcam" you installed the additional dependencies.')
 
     @property
     def cameras(self):

requirements.txt

@@ -11,4 +11,3 @@ pandas==1.1.4
 matplotlib==3.3.4
 scikit-image==0.17.2
 scipy==1.5.4
-pyzmq==20.0.0

utils/generic.py

@@ -6,13 +6,10 @@
 Licensed under GNU General Public License v3.0
 """
 import time
-import base64
-
 import cv2
 import numpy as np
-import zmq
 
-from utils.configloader import CAMERA_SOURCE, VIDEO_SOURCE, RESOLUTION, FRAMERATE, PORT, REPEAT_VIDEO
+from utils.configloader import CAMERA_SOURCE, VIDEO_SOURCE, RESOLUTION, FRAMERATE, REPEAT_VIDEO
 
 class MissingFrameError(Exception):
     """Custom expection to be raised when frame is not received. Should be caught in app.py and deeplabstream.py
@@ -157,72 +154,4 @@ def get_frames(self) -> tuple:
         return color_frames, depth_maps, infra_frames
 
 
-class WebCamManager(GenericManager):
-
-    def __init__(self):
-        """
-        Binds the computer to a ip address and starts listening for incoming streams.
-        Adapted from StreamViewer.py https://github.com/CT83/SmoothStream
-        """
-        super().__init__()
-        self._context = zmq.Context()
-        self._footage_socket = self._context.socket(zmq.SUB)
-        self._footage_socket.bind('tcp://*:' + PORT)
-        self._footage_socket.setsockopt_string(zmq.SUBSCRIBE, np.unicode(''))
-
-        self._camera = None
-        self._camera_name = "webcam"
-        self.initial_wait = False
-        self.last_frame_time = time.time()
-
-    @ staticmethod
-    def string_to_image(string):
-        """
-        Taken from https://github.com/CT83/SmoothStream
-        """
-
-        img = base64.b64decode(string)
-        npimg = np.fromstring(img, dtype=np.uint8)
-        return cv2.imdecode(npimg, 1)
-
-    def get_frames(self) -> tuple:
-        """
-        Collect frames for camera and outputs it in 'color' dictionary
-        ***depth and infrared are not used here***
-        :return: tuple of three dictionaries: color, depth, infrared
-        """
-
-        color_frames = {}
-        depth_maps = {}
-        infra_frames = {}
-
-        if self._footage_socket:
-            ret = True
-        else:
-            ret = False
-        self.last_frame_time = time.time()
-        if ret:
-            # if not self.initial_wait:
-            #     cv2.waitKey(1000)
-            #     self.initial_wait = True
-            # receives frame from stream
-            image = self._footage_socket.recv_string()
-            # converts image from str to image format that cv can handle
-            image = self.string_to_image(image)
-            image = cv2.resize(image, RESOLUTION)
-            color_frames[self._camera_name] = image
-            running_time = time.time() - self.last_frame_time
-            if running_time <= 1 / FRAMERATE:
-                sleepy_time = int(np.ceil(1000/FRAMERATE - running_time / 1000))
-                cv2.waitKey(sleepy_time)
-
-        else:
-            raise MissingFrameError('No frame was received from the webcam stream. Make sure that you started streaming on the host machine.')
 
-        return color_frames, depth_maps, infra_frames
-
-    def enable_stream(self, resolution, framerate, *args):
-        """
-        Not used for webcam streaming over network
-        """
-        pass

utils/webcam.py

@@ -0,0 +1,80 @@
+from utils.generic import GenericManager, MissingFrameError
+import time
+import base64
+
+import cv2
+import numpy as np
+import zmq
+
+from utils.configloader import RESOLUTION, FRAMERATE, PORT
+
+
+class WebCamManager(GenericManager):
+
+    def __init__(self):
+        """
+        Binds the computer to a ip address and starts listening for incoming streams.
+        Adapted from StreamViewer.py https://github.com/CT83/SmoothStream
+        """
+        super().__init__()
+        self._context = zmq.Context()
+        self._footage_socket = self._context.socket(zmq.SUB)
+        self._footage_socket.bind('tcp://*:' + PORT)
+        self._footage_socket.setsockopt_string(zmq.SUBSCRIBE, np.unicode(''))
+
+        self._camera = None
+        self._camera_name = "webcam"
+        self.initial_wait = False
+        self.last_frame_time = time.time()
+
+    @ staticmethod
+    def string_to_image(string):
+        """
+        Taken from https://github.com/CT83/SmoothStream
+        """
+
+        img = base64.b64decode(string)
+        npimg = np.fromstring(img, dtype=np.uint8)
+        return cv2.imdecode(npimg, 1)
+
+    def get_frames(self) -> tuple:
+        """
+        Collect frames for camera and outputs it in 'color' dictionary
+        ***depth and infrared are not used here***
+        :return: tuple of three dictionaries: color, depth, infrared
+        """
+
+        color_frames = {}
+        depth_maps = {}
+        infra_frames = {}
+
+        if self._footage_socket:
+            ret = True
+        else:
+            ret = False
+        self.last_frame_time = time.time()
+        if ret:
+            # if not self.initial_wait:
+            #     cv2.waitKey(1000)
+            #     self.initial_wait = True
+            # receives frame from stream
+            image = self._footage_socket.recv_string()
+            # converts image from str to image format that cv can handle
+            image = self.string_to_image(image)
+            image = cv2.resize(image, RESOLUTION)
+            color_frames[self._camera_name] = image
+            running_time = time.time() - self.last_frame_time
+            if running_time <= 1 / FRAMERATE:
+                sleepy_time = int(np.ceil(1000/FRAMERATE - running_time / 1000))
+                cv2.waitKey(sleepy_time)
+
+        else:
+            raise MissingFrameError('No frame was received from the webcam stream. Make sure that you started streaming on the host machine.')
+
+        return color_frames, depth_maps, infra_frames
+
+    def enable_stream(self, resolution, framerate, *args):
+        """
+        Not used for webcam streaming over network
+        """
+        pass