megadetector 10.0.5__py3-none-any.whl → 10.0.6__py3-none-any.whl

megadetector/detection/process_video.py

@@ -81,8 +81,8 @@ class ProcessVideoOptions:
         self.augment = False
 
         #: By default, a video with no frames (or no frames retrievable with the current parameters)
-        #: is treated as a failure; this causes it to be treated as a video with no detections.
-        self.allow_empty_videos = False
+        #: is silently stored as a failure; this causes it to halt execution.
+        self.exit_on_empty_video = False
 
         #: Detector-specific options
         self.detector_options = None
@@ -134,6 +134,14 @@ def process_videos(options):
     # Check for incompatible options
     _validate_video_options(options)
 
+    if options.output_json_file is None:
+        video_file = options.input_video_file.replace('\\','/')
+        if video_file.endswith('/'):
+            video_file = video_file[:-1]
+        options.output_json_file = video_file + '.json'
+        print('Output file not specified, defaulting to {}'.format(
+            options.output_json_file))
+
     assert options.output_json_file.endswith('.json'), \
         'Illegal output file {}'.format(options.output_json_file)
 
@@ -173,7 +181,7 @@ def process_videos(options):
                                                        every_n_frames=every_n_frames_param,
                                                        verbose=options.verbose,
                                                        files_to_process_relative=[video_bn],
-                                                       allow_empty_videos=options.allow_empty_videos)
+                                                       error_on_empty_video=options.exit_on_empty_video)
 
     else:
 
@@ -187,7 +195,7 @@ def process_videos(options):
                                                        every_n_frames=every_n_frames_param,
                                                        verbose=options.verbose,
                                                        recursive=options.recursive,
-                                                       allow_empty_videos=options.allow_empty_videos)
+                                                       error_on_empty_video=options.exit_on_empty_video)
 
     # ...whether we're processing a file or a folder
 
@@ -414,9 +422,10 @@ def main(): # noqa
                         action='store_true',
                         help='Enable image augmentation')
 
-    parser.add_argument('--allow_empty_videos',
+    parser.add_argument('--exit_on_empty_video',
                         action='store_true',
-                        help='By default, videos with no retrievable frames cause an error, this makes it a warning')
+                        help=('By default, videos with no retrievable frames are stored as failures; this' \
+                              'causes them to halt execution'))
 
     parser.add_argument(
         '--detector_options',

megadetector/detection/video_utils.py

@@ -101,6 +101,99 @@ def find_videos(dirname,
     return find_video_strings(files)
 
 
+#%% Shared function for opening videos
+
+DEFAULT_BACKEND = -1
+
+# This is the order in which we'll try to open backends.
+#
+# In general, the defaults are as follows, though they vary depending
+# on what's installed:
+#
+# Windows: CAP_DSHOW or CAP_MSMF
+# Linux: CAP_FFMPEG
+# macOS: CAP_AVFOUNDATION
+#
+# Technically if the default fails, we may try the same backend again, but this
+# is rare, and it's not worth the complexity of figuring out what the system
+# default is.
+backend_id_to_name = {
+    DEFAULT_BACKEND:'default',
+    cv2.CAP_FFMPEG: 'CAP_FFMPEG',
+    cv2.CAP_DSHOW: 'CAP_DSHOW',
+    cv2.CAP_MSMF: 'CAP_MSMF',
+    cv2.CAP_AVFOUNDATION: 'CAP_AVFOUNDATION',
+    cv2.CAP_GSTREAMER: 'CAP_GSTREAMER'
+}
+
+def open_video(video_path,verbose=False):
+    """
+    Open the video at [video_path], trying multiple OpenCV backends if necessary.
+
+    Args:
+        video_path (str): the file to open
+        verbose (bool, optional): enable additional debug output
+
+    Returns:
+        (cv2.VideoCapture,image): a tuple containing (a) the open video capture device
+        (or None if no backends succeeded) and (b) the first frame of the video (or None)
+    """
+
+    if not os.path.isfile(video_path):
+        print('Video file {} not found'.format(video_path))
+        return None,None
+
+    backend_ids = backend_id_to_name.keys()
+
+    for backend_id in backend_ids:
+
+        backend_name = backend_id_to_name[backend_id]
+        if verbose:
+            print('Trying backend {}'.format(backend_name))
+
+        try:
+            if backend_id == DEFAULT_BACKEND:
+                vidcap = cv2.VideoCapture(video_path)
+            else:
+                vidcap = cv2.VideoCapture(video_path, backend_id)
+        except Exception as e:
+            if verbose:
+                print('Warning: error opening {} with backend {}: {}'.format(
+                    video_path,backend_name,str(e)))
+            continue
+
+        if not vidcap.isOpened():
+            if verbose:
+                print('Warning: isOpened() is False for {} with backend {}'.format(
+                    video_path,backend_name))
+            try:
+                vidcap.release()
+            except Exception:
+                pass
+            continue
+
+        success, image = vidcap.read()
+        if success and (image is not None):
+            if verbose:
+                print('Successfully opened {} with backend: {}'.format(
+                    video_path,backend_name))
+            return vidcap,image
+
+        print('Warning: failed to open {} with backend {}'.format(
+            video_path,backend_name))
+        try:
+            vidcap.release()
+        except Exception:
+            pass
+
+    # ...for each backend
+
+    print('Error: failed to open {} with any backend'.format(video_path))
+    return None,None
+
+# ...def open_video(...)
+
+
 #%% Functions for rendering frames to video and vice-versa
 
 # http://tsaith.github.io/combine-images-into-a-video-with-python-3-and-opencv-3.html
@@ -146,21 +239,32 @@ def frames_to_video(images, fs, output_file_name, codec_spec=default_fourcc):
     cv2.destroyAllWindows()
 
 
-def get_video_fs(input_video_file):
+def get_video_fs(input_video_file,verbose=False):
     """
     Retrieves the frame rate of [input_video_file].
 
     Args:
         input_video_file (str): video file for which we want the frame rate
+        verbose (bool, optional): enable additional debug output
 
     Returns:
-        float: the frame rate of [input_video_file]
+        float: the frame rate of [input_video_file], or None if no frame
+            rate could be extracted
     """
 
-    assert os.path.isfile(input_video_file), 'File {} not found'.format(input_video_file)
-    vidcap = cv2.VideoCapture(input_video_file)
+    assert os.path.isfile(input_video_file), \
+        'File {} not found'.format(input_video_file)
+    vidcap,_ = open_video(input_video_file,verbose=verbose)
+    if vidcap is None:
+        if verbose:
+            print('Failed to get frame rate for {}'.format(input_video_file))
+        return None
     fs = vidcap.get(cv2.CAP_PROP_FPS)
-    vidcap.release()
+    try:
+        vidcap.release()
+    except Exception as e:
+        print('Warning: error closing video handle for {}: {}'.format(
+            input_video_file,str(e)))
     return fs
 
 
@@ -249,7 +353,7 @@ def run_callback_on_frames(input_video_file,
             of the video, no frames are extracted.  Can also be a single int, specifying
             a single frame number.
         allow_empty_videos (bool, optional): Just print a warning if a video appears to have no
-            frames (by default, this is an error).
+            frames (by default, this raises an Exception).
 
     Returns:
         dict: dict with keys 'frame_filenames' (list), 'frame_rate' (float), 'results' (list).
@@ -271,7 +375,7 @@ def run_callback_on_frames(input_video_file,
 
     try:
 
-        vidcap = cv2.VideoCapture(input_video_file)
+        vidcap,image = open_video(input_video_file,verbose=verbose)
         n_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
         frame_rate = vidcap.get(cv2.CAP_PROP_FPS)
 
@@ -300,7 +404,11 @@ def run_callback_on_frames(input_video_file,
         # frame_number = 0
         for frame_number in range(0,n_frames):
 
-            success,image = vidcap.read()
+            # We've already read the first frame, when we opened the video
+            if frame_number != 0:
+                success,image = vidcap.read()
+            else:
+                success = True
 
             if not success:
                 assert image is None
@@ -363,9 +471,9 @@ def run_callback_on_frames_for_folder(input_video_folder,
                                       frame_callback,
                                       every_n_frames=None,
                                       verbose=False,
-                                      allow_empty_videos=False,
                                       recursive=True,
-                                      files_to_process_relative=None):
+                                      files_to_process_relative=None,
+                                      error_on_empty_video=False):
     """
     Calls the function frame_callback(np.array,image_id) on all (or selected) frames in
     all videos in [input_video_folder].
@@ -382,10 +490,10 @@ def run_callback_on_frames_for_folder(input_video_folder,
             interpreted as a sampling rate in seconds, which is rounded to the nearest frame
             sampling rate.
         verbose (bool, optional): enable additional debug console output
-        allow_empty_videos (bool, optional): Just print a warning if a video appears to have no
-            frames (by default, this is an error).
         recursive (bool, optional): recurse into [input_video_folder]
         files_to_process_relative (list, optional): only process specific relative paths
+        error_on_empty_video (bool, optional): by default, videos with errors or no valid frames
+            are silently stored as failures; this turns them into exceptions
 
     Returns:
         dict: dict with keys 'video_filenames' (list of str), 'frame_rates' (list of floats),
@@ -440,18 +548,21 @@ def run_callback_on_frames_for_folder(input_video_folder,
                                                    every_n_frames=every_n_frames,
                                                    verbose=verbose,
                                                    frames_to_process=None,
-                                                   allow_empty_videos=allow_empty_videos)
+                                                   allow_empty_videos=False)
 
         except Exception as e:
 
-            print('Warning: error processing video {}: {}'.format(
-                video_fn_abs,str(e)
-            ))
-            to_return['frame_rates'].append(-1.0)
-            failure_result = {}
-            failure_result['failure'] = 'Failure processing video: {}'.format(str(e))
-            to_return['results'].append(failure_result)
-            continue
+            if (not error_on_empty_video):
+                print('Warning: error processing video {}: {}'.format(
+                    video_fn_abs,str(e)
+                ))
+                to_return['frame_rates'].append(-1.0)
+                failure_result = {}
+                failure_result['failure'] = 'Failure processing video: {}'.format(str(e))
+                to_return['results'].append(failure_result)
+                continue
+            else:
+                raise
 
         # ...try/except
 

{megadetector-10.0.5.dist-info → megadetector-10.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: megadetector
-Version: 10.0.5
+Version: 10.0.6
 Summary: MegaDetector is an AI model that helps conservation folks spend less time doing boring things with camera trap images.
 Author-email: Your friendly neighborhood MegaDetector team <cameratraps@lila.science>
 Maintainer-email: Your friendly neighborhood MegaDetector team <cameratraps@lila.science>

{megadetector-10.0.5.dist-info → megadetector-10.0.6.dist-info}/RECORD

@@ -72,7 +72,7 @@ megadetector/data_management/lila/lila_common.py,sha256=IRWs46TrxcjckLidDwXPmb5O
 megadetector/data_management/lila/test_lila_metadata_urls.py,sha256=ThU78Ks5V3rFyJSKStFcM5M2yTlhR_pgMTa6_KuF5Hs,5256
 megadetector/detection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 megadetector/detection/change_detection.py,sha256=Ne3GajbH_0KPBU8ruHp4Rkr0uKd5oKAMQ3CQTRKRHgQ,28659
-megadetector/detection/process_video.py,sha256=iE-TA42IhrVwl3ftZ12mgaWv5CuttsI5SsivxSzpRiY,17498
+megadetector/detection/process_video.py,sha256=kuQHrpOC3LQo9ecqJPpzkds9fZVnoLmrfJw_yh-oxi8,17890
 megadetector/detection/pytorch_detector.py,sha256=ixU-2_AnCwEP33FaaqTZRoi1WxIUeM4x_ksbNT-tezA,59817
 megadetector/detection/run_detector.py,sha256=TTX29zxDN_O7ja61sOmMIVewUz3yRvKg1D1AAYhVEkc,46851
 megadetector/detection/run_detector_batch.py,sha256=aZgiywL6arrdQ_l3jzlHctlccqL537lwVStjhi1hIWw,89823
@@ -80,7 +80,7 @@ megadetector/detection/run_inference_with_yolov5_val.py,sha256=A-AQuARVVy7oR9Wte
 megadetector/detection/run_md_and_speciesnet.py,sha256=Dp_SpJZp0pX9jzFtxM6zPCyBNq49uyQpMDAdNDLVorM,50280
 megadetector/detection/run_tiled_inference.py,sha256=wrQkKIloHBO9v2i0nZ1_Tt75iFtVrnco3Y4FafoVxdw,39382
 megadetector/detection/tf_detector.py,sha256=3b2MiqgMw8KBDzHQliUSDXWrmKpa9iZnfe6EgYpMcYo,8398
-megadetector/detection/video_utils.py,sha256=JkCTK1-aNmLDHOEvlI1w5KS2ZssSdgzerLIUE8iX2_I,49785
+megadetector/detection/video_utils.py,sha256=AlmNJ5n7qmv3Z65HcjI1ALAxXMmyTG3pUiO7oJm-8rs,53363
 megadetector/postprocessing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 megadetector/postprocessing/add_max_conf.py,sha256=9MYtsH2mwkiaZb7Qcor5J_HskfAj7d9srp8G_Qldpk0,1722
 megadetector/postprocessing/categorize_detections_by_size.py,sha256=DpZpRNFlyeOfWuOc6ICuENgIWDCEtiErJ_frBZp9lYM,5382
@@ -140,8 +140,8 @@ megadetector/visualization/visualization_utils.py,sha256=E5uvysS3F1S_yiPFxZty3U2
 megadetector/visualization/visualize_db.py,sha256=8YDWSR0eMehXYdPtak9z8UUw35xV7hu-0eCuzgSLjWc,25558
 megadetector/visualization/visualize_detector_output.py,sha256=HpWh7ugwo51YBHsFi40iAp9G-uRAMMjgsm8H_uBolBs,20295
 megadetector/visualization/visualize_video_output.py,sha256=4A5uit_JVV46kZCsO6j0bZ5-o6ZTAlXKuVvvR_xWpho,20266
-megadetector-10.0.5.dist-info/licenses/LICENSE,sha256=RMa3qq-7Cyk7DdtqRj_bP1oInGFgjyHn9-PZ3PcrqIs,1100
-megadetector-10.0.5.dist-info/METADATA,sha256=i5TpLpLfLxIXO5brvz7yqqKlZ3K5mnvHfoeXExTJCXI,6352
-megadetector-10.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-megadetector-10.0.5.dist-info/top_level.txt,sha256=wf9DXa8EwiOSZ4G5IPjakSxBPxTDjhYYnqWRfR-zS4M,13
-megadetector-10.0.5.dist-info/RECORD,,
+megadetector-10.0.6.dist-info/licenses/LICENSE,sha256=RMa3qq-7Cyk7DdtqRj_bP1oInGFgjyHn9-PZ3PcrqIs,1100
+megadetector-10.0.6.dist-info/METADATA,sha256=KjAHAEEE_ELiV6BtcFx_bfjKJg9fxFFEOF_0uHtbp3s,6352
+megadetector-10.0.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+megadetector-10.0.6.dist-info/top_level.txt,sha256=wf9DXa8EwiOSZ4G5IPjakSxBPxTDjhYYnqWRfR-zS4M,13
+megadetector-10.0.6.dist-info/RECORD,,