Fix review issues: safe cv2.cuda guard, use_gpu defaults to False, move imports to module level, add blur_faces and pose GPU tests

Author: alexarje

musicalgestures/_blurfaces.py

@@ -80,7 +80,7 @@ def mg_blurfaces(self,
                  save_data=True, 
                  data_format='csv', 
                  color=(0, 0, 0), 
-                 use_gpu=True,
+                 use_gpu=False,
                  target_name=None, 
                  overwrite=False):
     """
@@ -102,7 +102,7 @@ def mg_blurfaces(self,
         save_data (bool, optional): Whether to save the scaled coordinates of the face mask (time (ms), x1, y1, x2, y2) for each frame to a file. Defaults to True.
         data_format (str, optional): Specifies format of blur_faces-data. Accepted values are 'csv', 'tsv' and 'txt'. For multiple output formats, use list, e.g. ['csv', 'txt']. Defaults to 'csv'.
         color (tuple, optional): Customized color of the rectangle boxes. Defaults to black (0, 0, 0).
-        use_gpu (bool, optional): Whether to attempt GPU (CUDA) acceleration for face detection. Falls back to CPU automatically if CUDA is unavailable. Defaults to True.
+        use_gpu (bool, optional): Whether to attempt GPU (CUDA) acceleration for face detection. Falls back to CPU automatically if CUDA is unavailable. Defaults to False.
         target_name (str, optional): Target output name. Defaults to None (which assumes that the input filename with the suffix "_blurred" should be used).
         overwrite (bool, optional): Whether to allow overwriting existing files or to automatically increment target filenames to avoid overwriting. Defaults to False.
 

musicalgestures/_flow.py

@@ -7,7 +7,7 @@
 from scipy.stats import entropy
 
 import musicalgestures
-from musicalgestures._utils import MgFigure, extract_wav, embed_audio_in_video, MgProgressbar, convert_to_avi, generate_outfilename, ffmpeg_cmd
+from musicalgestures._utils import MgFigure, extract_wav, embed_audio_in_video, MgProgressbar, convert_to_avi, generate_outfilename, ffmpeg_cmd, get_cuda_device_count
 
 
 class Flow:
@@ -47,7 +47,7 @@ def dense(
             angle_of_view=0, 
             scaledown=1,      
             skip_empty=False,
-            use_gpu=True,
+            use_gpu=False,
             target_name=None,
             overwrite=False):
         """
@@ -69,7 +69,7 @@ def dense(
             angle_of_view (int, optional): angle of view of camera, for reporting flow in meters per second. Defaults to 0.
             scaledown (int, optional): factor to scaledown frame size of the video. Defaults to 1.
             skip_empty (bool, optional): If True, repeats previous frame in the output when encounters an empty frame. Defaults to False.
-            use_gpu (bool, optional): Whether to attempt GPU (CUDA) acceleration using `cv2.cuda.FarnebackOpticalFlow`. When `True`, falls back to CPU automatically if CUDA is unavailable or the required OpenCV CUDA modules are not installed. When `False`, CPU processing is used unconditionally. Defaults to True.
+            use_gpu (bool, optional): Whether to attempt GPU (CUDA) acceleration using `cv2.cuda.FarnebackOpticalFlow`. When `True`, falls back to CPU automatically if CUDA is unavailable or the required OpenCV CUDA modules are not installed. When `False`, CPU processing is used unconditionally. Defaults to False.
             target_name (str, optional): Target output name for the video. Defaults to None (which assumes that the input filename with the suffix "_flow_dense" should be used).
             overwrite (bool, optional): Whether to allow overwriting existing files or to automatically increment target filenames to avoid overwriting. Defaults to False.
 
@@ -103,11 +103,10 @@ def dense(
         size = (int(width/scaledown), int(height/scaledown))
 
         # Determine whether to use GPU-accelerated Farneback optical flow
-        from musicalgestures._utils import get_cuda_device_count
         _use_gpu = False
         farneback_gpu = None
         if use_gpu:
-            if not hasattr(cv2.cuda, 'FarnebackOpticalFlow'):
+            if not hasattr(cv2, 'cuda') or not hasattr(cv2.cuda, 'FarnebackOpticalFlow'):
                 print('cv2.cuda.FarnebackOpticalFlow is unavailable (requires opencv-contrib built with CUDA). Switching to CPU for dense optical flow.')
             elif get_cuda_device_count() <= 0:
                 print('OpenCV CUDA backend is unavailable. Switching to CPU for dense optical flow.')
@@ -322,7 +321,7 @@ def sparse(
             of_max_level=2,
             of_criteria=(cv2.TERM_CRITERIA_EPS |
                          cv2.TERM_CRITERIA_COUNT, 10, 0.03),
-            use_gpu=True,
+            use_gpu=False,
             target_name=None,
             overwrite=False):
         """
@@ -337,7 +336,7 @@ def sparse(
             of_win_size (tuple, optional): Size of the search window at each pyramid level. Defaults to (15, 15).
             of_max_level (int, optional): 0-based maximal pyramid level number. If set to 0, pyramids are not used (single level), if set to 1, two levels are used, and so on. If pyramids are passed to input then the algorithm will use as many levels as pyramids have but no more than `maxLevel`. Defaults to 2.
             of_criteria (tuple, optional): Specifies the termination criteria of the iterative search algorithm (after the specified maximum number of iterations criteria.maxCount or when the search window moves by less than criteria.epsilon). Defaults to (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03).
-            use_gpu (bool, optional): Whether to attempt GPU (CUDA) acceleration using `cv2.cuda.SparsePyrLKOpticalFlow`. When `True`, falls back to CPU automatically if CUDA is unavailable or the required OpenCV CUDA modules are not installed. When `False`, CPU processing is used unconditionally. Defaults to True.
+            use_gpu (bool, optional): Whether to attempt GPU (CUDA) acceleration using `cv2.cuda.SparsePyrLKOpticalFlow`. When `True`, falls back to CPU automatically if CUDA is unavailable or the required OpenCV CUDA modules are not installed. When `False`, CPU processing is used unconditionally. Defaults to False.
             target_name (str, optional): Target output name for the video. Defaults to None (which assumes that the input filename with the suffix "_flow_sparse" should be used).
             overwrite (bool, optional): Whether to allow overwriting existing files or to automatically increment target filenames to avoid overwriting. Defaults to False.
 
@@ -370,11 +369,10 @@ def sparse(
         length = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
 
         # Determine whether to use GPU-accelerated sparse optical flow
-        from musicalgestures._utils import get_cuda_device_count
         _use_gpu = False
         lk_gpu = None
         if use_gpu:
-            if not hasattr(cv2.cuda, 'SparsePyrLKOpticalFlow'):
+            if not hasattr(cv2, 'cuda') or not hasattr(cv2.cuda, 'SparsePyrLKOpticalFlow'):
                 print('cv2.cuda.SparsePyrLKOpticalFlow is unavailable (requires opencv-contrib built with CUDA). Switching to CPU for sparse optical flow.')
             elif get_cuda_device_count() <= 0:
                 print('OpenCV CUDA backend is unavailable. Switching to CPU for sparse optical flow.')

musicalgestures/_utils.py

@@ -1624,7 +1624,6 @@ def get_cuda_device_count():
         int: Number of available CUDA devices, or 0 if the OpenCV CUDA
              module is unavailable or no devices are detected.
     """
-    import cv2
     try:
         return cv2.cuda.getCudaEnabledDeviceCount()
     except Exception:

tests/test_flow.py

@@ -113,3 +113,33 @@ def test_returns_int(self):
         result = musicalgestures.get_cuda_device_count()
         assert isinstance(result, int)
         assert result >= 0
+
+
+class Test_blur_faces_gpu:
+    def test_use_gpu_false(self, testvideo_avi):
+        mg = musicalgestures.MgVideo(testvideo_avi)
+        result = mg.blur_faces(use_gpu=False, overwrite=True)
+        assert type(result) == musicalgestures.MgVideo
+        assert os.path.isfile(result.filename) == True
+
+    def test_use_gpu_true(self, testvideo_avi):
+        # use_gpu=True should work (falls back to CPU when CUDA is unavailable)
+        mg = musicalgestures.MgVideo(testvideo_avi)
+        result = mg.blur_faces(use_gpu=True, overwrite=True)
+        assert type(result) == musicalgestures.MgVideo
+        assert os.path.isfile(result.filename) == True
+
+
+class Test_pose_gpu:
+    def test_device_cpu(self, testvideo_avi):
+        mg = musicalgestures.MgVideo(testvideo_avi)
+        result = mg.pose(device='cpu', overwrite=True)
+        assert type(result) == musicalgestures.MgVideo
+        assert os.path.isfile(result.filename) == True
+
+    def test_device_gpu_fallback(self, testvideo_avi):
+        # device='gpu' should fall back to CPU when CUDA is unavailable
+        mg = musicalgestures.MgVideo(testvideo_avi)
+        result = mg.pose(device='gpu', overwrite=True)
+        assert type(result) == musicalgestures.MgVideo
+        assert os.path.isfile(result.filename) == True