megadetector 5.0.29__py3-none-any.whl → 10.0.1__py3-none-any.whl

megadetector/data_management/yolo_output_to_md_output.py

@@ -40,6 +40,8 @@ import json
 import csv
 import os
 import re
+import sys
+import argparse
 
 from collections import defaultdict
 from tqdm import tqdm
@@ -123,8 +125,9 @@ def yolo_json_output_to_md_output(yolo_json_file,
     Converts a YOLOv5/YOLOv8 .json file to MD .json format.
 
     Args:
-        yolo_json_file (str): the .json file to convert from YOLOv5 format to MD output format
+        yolo_json_file (str): the YOLO-formatted .json file to convert to MD output format
         image_folder (str): the .json file contains relative path names, this is the path base
+        output_file (str): the MD-formatted .json file to write
         yolo_category_id_to_name (str or dict): the .json results file contains only numeric
             identifiers for categories, but we want names and numbers for the output format;
             yolo_category_id_to_name provides that mapping either as a dict or as a YOLOv5
@@ -460,4 +463,130 @@ if False:
 
 #%% Command-line driver
 
-# TODO
+def main():
+    """
+    Command-line interface to convert YOLOv5/YOLOv8 output (.json or .txt)
+    to MegaDetector output format.
+    """
+
+    parser = argparse.ArgumentParser(
+        description='Converts YOLOv5 output (.json or .txt) to MD output format.'
+    )
+
+    # The first argument determines which series of additional arguments are supported, for
+    # json/txt input
+    subparsers = parser.add_subparsers(dest='mode', required=True,
+        help="Mode of operation: 'json' for YOLO JSON output, 'txt' for YOLO TXT output.")
+
+
+    ## 'json' mode subparser
+
+    parser_json = subparsers.add_parser('json', help='Convert YOLO-formatted .json results.')
+
+    parser_json.add_argument(
+        'yolo_json_file', type=str,
+        help='Path to the input YOLO-formatted .json results file'
+    )
+    parser_json.add_argument(
+        'image_folder', type=str,
+        help='Path to the image folder'
+    )
+    parser_json.add_argument(
+        'output_file', type=str,
+        help='Path to the MD-formatted .json output file'
+    )
+    parser_json.add_argument(
+        'yolo_category_id_to_name_file', type=str,
+        help='Path to the .yml, .yaml, .json, or .txt file mapping YOLO category IDs to names'
+    )
+    parser_json.add_argument(
+        '--detector_name', type=str, default='unknown',
+        help="Detector name to store in the output file (default: 'unknown')"
+    )
+    parser_json.add_argument(
+        '--image_id_to_relative_path_file', type=str, default=None,
+        help='Path to a .json file mapping image IDs to relative paths'
+    )
+    parser_json.add_argument(
+        '--offset_yolo_class_ids', type=str, default='true', choices=['true', 'false'],
+        help="Offset YOLO class IDs in the output (default: 'true')"
+    )
+    parser_json.add_argument(
+        '--truncate_to_standard_md_precision', type=str, default='true', choices=['true', 'false'],
+        help="Truncate coordinates and confidences to standard MD precision (default: 'true')"
+    )
+    parser_json.add_argument(
+        '--convert_slashes', type=str, default='true', choices=['true', 'false'],
+        help="Convert backslashes to forward slashes in output file paths (default: 'true')"
+    )
+
+
+    ## 'txt' mode subparser
+
+    parser_txt = subparsers.add_parser('txt', help='Convert YOLO-formatted .txt results from a folder')
+    parser_txt.add_argument(
+        'input_results_folder', type=str,
+        help='Path to the folder containing YOLO .txt output files'
+    )
+    parser_txt.add_argument(
+        'image_folder', type=str,
+        help='Path to the image folder'
+    )
+    parser_txt.add_argument(
+        'output_file', type=str,
+        help='Path to the MD-formatted .json  file output'
+    )
+    parser_txt.add_argument(
+        '--detector_tag', type=str, default=None,
+        help='Detector tag to store in the output file'
+    )
+    parser_txt.add_argument(
+        '--truncate_to_standard_md_precision', type=str, default='true', choices=['true', 'false'],
+        help="Truncate coordinates and confidences to standard MD precision (default: 'true')."
+    )
+
+    args = parser.parse_args()
+
+    if args.mode == 'json':
+
+        image_id_to_relative_path = None
+        if args.image_id_to_relative_path_file:
+            try:
+                with open(args.image_id_to_relative_path_file, 'r') as f:
+                    image_id_to_relative_path = json.load(f)
+            except Exception as e:
+                print(f"Error loading image_id_to_relative_path_file: {e}")
+                sys.exit(1)
+
+        offset_yolo_class_ids = args.offset_yolo_class_ids.lower() == 'true'
+        truncate_json = args.truncate_to_standard_md_precision.lower() == 'true'
+        convert_slashes = args.convert_slashes.lower() == 'true'
+
+        yolo_json_output_to_md_output(
+            yolo_json_file=args.yolo_json_file,
+            image_folder=args.image_folder,
+            output_file=args.output_file,
+            yolo_category_id_to_name=args.yolo_category_id_to_name_file, # Function handles reading this file
+            detector_name=args.detector_name,
+            image_id_to_relative_path=image_id_to_relative_path,
+            offset_yolo_class_ids=offset_yolo_class_ids,
+            truncate_to_standard_md_precision=truncate_json,
+            convert_slashes=convert_slashes
+        )
+        print('Converted {} to {}'.format(args.yolo_json_file,args.output_file))
+
+    elif args.mode == 'txt':
+
+        truncate_txt = args.truncate_to_standard_md_precision.lower() == 'true'
+
+        yolo_txt_output_to_md_output(
+            input_results_folder=args.input_results_folder,
+            image_folder=args.image_folder,
+            output_file=args.output_file,
+            detector_tag=args.detector_tag,
+            truncate_to_standard_md_precision=truncate_txt
+        )
+        print('Converted results from {} to {}'.format(args.input_results_folder,args.output_file))
+
+if __name__ == '__main__':
+    main()

megadetector/data_management/yolo_to_coco.py

@@ -10,6 +10,8 @@ Converts a folder of YOLO-formatted annotation files to a COCO-formatted dataset
 
 import json
 import os
+import argparse
+import sys
 
 from multiprocessing.pool import ThreadPool
 from multiprocessing.pool import Pool
@@ -22,7 +24,8 @@ from megadetector.utils.path_utils import recursive_file_list
 from megadetector.utils.path_utils import find_image_strings
 from megadetector.utils.ct_utils import invert_dictionary
 from megadetector.visualization.visualization_utils import open_image
-from megadetector.data_management.yolo_output_to_md_output import read_classes_from_yolo_dataset_file
+from megadetector.data_management.yolo_output_to_md_output import \
+    read_classes_from_yolo_dataset_file
 
 
 #%% Support functions
@@ -430,7 +433,7 @@ def yolo_to_coco(input_folder,
             input_folder as the base folder, though this is not explicitly checked.
         output_file (str, optional): .json file to which we should write COCO .json data
         empty_image_handling (str, optional): how to handle images with no boxes; whether
-            this includes images with no .txt files depending on the value of
+            this includes images with no .txt files depends on the value of
             [allow_images_without_label_files].  Can be:
 
             - 'no_annotations': include the image in the image list, with no annotations
@@ -438,12 +441,15 @@ def yolo_to_coco(input_folder,
               any bounding boxes, using a category called [empty_image_category_name].
             - 'skip': don't include the image in the image list
             - 'error': there shouldn't be any empty images
+        empty_image_category_name (str, optional): if we're going to be inserting annotations for
+            images with no boxes, what category name should we use?
         error_image_handling (str, optional): how to handle images that don't load properly; can
             be:
 
             - 'skip': don't include the image at all
             - 'no_annotations': include with no annotations
-
+        allow_images_without_label_files (bool, optional): whether to silently allow images with
+            no label files (True) or raise errors for images with no label files (False)
         n_workers (int, optional): number of concurrent workers, set to <= 1 to disable
             parallelization
         pool_type (str, optional): 'thread' or 'process', worker type to use for parallelization;
@@ -493,7 +499,7 @@ def yolo_to_coco(input_folder,
     # Find or create the empty image category, if necessary
     empty_category_id = None
 
-    if (empty_image_handling == 'empty_annotations'):
+    if empty_image_handling == 'empty_annotations':
         category_name_to_id = invert_dictionary(category_id_to_name)
         if empty_image_category_name in category_name_to_id:
             empty_category_id = category_name_to_id[empty_image_category_name]
@@ -652,6 +658,11 @@ def yolo_to_coco(input_folder,
 
     # ...for each image result
 
+    # Clean up unnecessary error fields
+    for im in images:
+        if 'error' in im and im['error'] is None:
+            del im['error']
+
     print('Read {} annotations for {} images'.format(len(annotations),
                                                      len(images)))
 
@@ -729,4 +740,128 @@ if False:
 
 #%% Command-line driver
 
-# TODO
+def main():
+    """
+    Command-line driver for YOLO to COCO conversion.
+    """
+
+    parser = argparse.ArgumentParser(
+        description='Convert a YOLO-formatted dataset to COCO format'
+    )
+    parser.add_argument(
+        'input_folder',
+        type=str,
+        help='Path to the YOLO dataset folder (image folder)'
+    )
+    parser.add_argument(
+        'class_name_file',
+        type=str,
+        help='Path to the file containing class names (e.g., classes.txt or dataset.yaml)'
+    )
+    parser.add_argument(
+        'output_file',
+        type=str,
+        help='Path to the output COCO .json file.'
+    )
+    parser.add_argument(
+        '--label_folder',
+        type=str,
+        default=None,
+        help='Label folder, if different from the image folder. Default: None (labels are in the image folder)'
+    )
+    parser.add_argument(
+        '--empty_image_handling',
+        type=str,
+        default='no_annotations',
+        choices=['no_annotations', 'empty_annotations', 'skip', 'error'],
+        help='How to handle images with no bounding boxes.'
+    )
+    parser.add_argument(
+        '--empty_image_category_name',
+        type=str,
+        default='empty',
+        help='Category name for empty images if empty_image_handling is "empty_annotations"'
+    )
+    parser.add_argument(
+        '--error_image_handling',
+        type=str,
+        default='no_annotations',
+        choices=['skip', 'no_annotations'],
+        help='How to handle images that fail to load'
+    )
+    parser.add_argument(
+        '--allow_images_without_label_files',
+        type=str,
+        default='true',
+        choices=['true', 'false'],
+        help='Whether to allow images that do not have corresponding label files (true/false)'
+    )
+    parser.add_argument(
+        '--n_workers',
+        type=int,
+        default=1,
+        help='Number of workers for parallel processing. <=1 for sequential'
+    )
+    parser.add_argument(
+        '--pool_type',
+        type=str,
+        default='thread',
+        choices=['thread', 'process'],
+        help='Type of multiprocessing pool if n_workers > 1'
+    )
+    parser.add_argument(
+        '--recursive',
+        type=str,
+        default='true',
+        choices=['true', 'false'],
+        help='Whether to search for images recursively in the input folder (true/false)'
+    )
+    parser.add_argument(
+        '--exclude_string',
+        type=str,
+        default=None,
+        help='Exclude images whose filename contains this string'
+    )
+    parser.add_argument(
+        '--include_string',
+        type=str,
+        default=None,
+        help='Include images only if filename contains this string'
+    )
+    parser.add_argument(
+        '--overwrite_handling',
+        type=str,
+        default='overwrite',
+        choices=['load', 'overwrite', 'error'],
+        help='Behavior if output_file exists.'
+    )
+
+    if len(sys.argv[1:]) == 0:
+        parser.print_help()
+        parser.exit()
+
+    args = parser.parse_args()
+
+    parsed_allow_images = args.allow_images_without_label_files.lower() == 'true'
+    parsed_recursive = args.recursive.lower() == 'true'
+
+    yolo_to_coco(
+        args.input_folder,
+        args.class_name_file,
+        output_file=args.output_file,
+        label_folder=args.label_folder,
+        empty_image_handling=args.empty_image_handling,
+        empty_image_category_name=args.empty_image_category_name,
+        error_image_handling=args.error_image_handling,
+        allow_images_without_label_files=parsed_allow_images,
+        n_workers=args.n_workers,
+        pool_type=args.pool_type,
+        recursive=parsed_recursive,
+        exclude_string=args.exclude_string,
+        include_string=args.include_string,
+        overwrite_handling=args.overwrite_handling
+    )
+    print(f"Dataset conversion complete, output written to {args.output_file}")
+
+if __name__ == '__main__':
+    main()

megadetector/detection/change_detection.py

@@ -228,7 +228,8 @@ def detect_motion(prev_image_path,
         curr_image_path (str): path to the current image
         options (ChangeDetectionOptions, optional): detection settings
         motion_state (MotionHistoryState, optional): state for motion history
-        bg_subtractor: background subtractor model for MOG2/KNN methods
+        bg_subtractor (cv2 background subtractor object): background subtractor model for
+            MOG2/KNN methods
 
     Returns:
         tuple: (motion_result, updated_motion_state)
@@ -611,8 +612,8 @@ def create_change_previews(motion_results, output_folder, num_samples=10, random
     Create side-by-side previews of images with detected motion
 
     Args:
-        motion_results: DataFrame with motion detection results
-        output_folder: folder where preview images will be saved
+        motion_results (DataFrame): DataFrame with motion detection results
+        output_folder (str): folder where preview images will be saved
         num_samples (int, optional): number of random samples to create
         random_seed (int, optional): seed for random sampling (for reproducibility)
 

megadetector/detection/pytorch_detector.py

@@ -28,7 +28,6 @@ from megadetector.detection.run_detector import \
     get_detector_version_from_model_file, \
     known_models
 from megadetector.utils.ct_utils import parse_bool_string
-from megadetector.utils.ct_utils import to_bool
 from megadetector.utils import ct_utils
 
 # We support a few ways of accessing the YOLOv5 dependencies:
@@ -176,7 +175,7 @@ def _initialize_yolo_imports_for_model(model_file,
     return model_type
 
 
-def _clean_yolo_imports(verbose=False):
+def _clean_yolo_imports(verbose=False,aggressive_cleanup=False):
     """
     Remove all YOLO-related imports from sys.modules and sys.path, to allow a clean re-import
     of another YOLO library version.  The reason we jump through all these hoops, rather than
@@ -187,30 +186,68 @@ def _clean_yolo_imports(verbose=False):
 
     Args:
         verbose (bool, optional): enable additional debug output
+        aggressive_cleanup (bool, optional): err on the side of removing modules,
+            at least by ignoring whether they are/aren't in a site-packages folder.
+            By default, only modules in a folder that includes "site-packages" will
+            be considered for unloading.
     """
 
     modules_to_delete = []
+
     for module_name in sys.modules.keys():
+
         module = sys.modules[module_name]
+        if not hasattr(module,'__file__') or (module.__file__ is None):
+            continue
         try:
             module_file = module.__file__.replace('\\','/')
-            if 'site-packages' not in module_file:
-                continue
-            tokens = module_file.split('/')[-4:]
-            for token in tokens:
-                if 'yolov5' in token or 'yolov9' in token or 'ultralytics' in token:
+            if not aggressive_cleanup:
+                if 'site-packages' not in module_file:
+                    continue
+            tokens = module_file.split('/')
+
+            # For local path imports, a module filename that should be unloaded might
+            # look like:
+            #
+            # c:/git/yolov9/models/common.py
+            #
+            # For pip imports, a module filename that should be unloaded might look like:
+            #
+            # c:/users/user/miniforge3/envs/megadetector/lib/site-packages/yolov9/utils/__init__.py
+            first_token_to_check = len(tokens) - 4
+            for i_token,token in enumerate(tokens):
+                if i_token < first_token_to_check:
+                    continue
+                # Don't remove anything based on the environment name, which
+                # always follows "envs" in the path
+                if (i_token > 1) and (tokens[i_token-1] == 'envs'):
+                    continue
+                if ('yolov5' in token) or ('yolov9' in token) or ('ultralytics' in token):
+                    if verbose:
+                        print('Module {} ({}) looks deletable'.format(module_name,module_file))
                     modules_to_delete.append(module_name)
                     break
-        except Exception:
+        except Exception as e:
+            if verbose:
+                print('Exception during module review: {}'.format(str(e)))
             pass
 
+    # ...for each module in the global namespace
+
     for module_name in modules_to_delete:
+
         if module_name in sys.modules.keys():
-            module_file = module.__file__.replace('\\','/')
             if verbose:
-                print('clean_yolo_imports: deleting module {}: {}'.format(module_name,module_file))
+                try:
+                    module = sys.modules[module_name]
+                    module_file = module.__file__.replace('\\','/')
+                    print('clean_yolo_imports: deleting module {}: {}'.format(module_name,module_file))
+                except Exception:
+                    pass
             del sys.modules[module_name]
 
+    # ...for each module we want to remove from the global namespace
+
     paths_to_delete = []
 
     for p in sys.path:
@@ -227,7 +264,7 @@ def _clean_yolo_imports(verbose=False):
 def _initialize_yolo_imports(model_type='yolov5',
                              allow_fallback_import=True,
                              force_reimport=False,
-                             verbose=True):
+                             verbose=False):
     """
     Imports required functions from one or more yolo libraries (yolov5, yolov9,
     ultralytics, targeting support for [model_type]).
@@ -246,7 +283,7 @@ def _initialize_yolo_imports(model_type='yolov5',
     """
 
     # When running in pytest, the megadetector 'utils' module is put in the global
-    # namespace, which creates conflicts with yolov5; remove it from the global 
+    # namespace, which creates conflicts with yolov5; remove it from the global
     # namespsace.
     if ('PYTEST_CURRENT_TEST' in os.environ):
         print('*** pytest detected ***')
@@ -328,7 +365,7 @@ def _initialize_yolo_imports(model_type='yolov5',
 
         try:
 
-            import ultralytics # noqa
+            import ultralytics # type: ignore # noqa
 
         except Exception:
 
@@ -340,15 +377,15 @@ def _initialize_yolo_imports(model_type='yolov5',
 
         try:
 
-            from ultralytics.utils.ops import non_max_suppression # noqa
-            from ultralytics.utils.ops import xyxy2xywh # noqa
+            from ultralytics.utils.ops import non_max_suppression # type: ignore # noqa
+            from ultralytics.utils.ops import xyxy2xywh # type: ignore # noqa
 
             # In the ultralytics package, scale_boxes and scale_coords both exist;
             # we want scale_boxes.
             #
             # from ultralytics.utils.ops import scale_coords # noqa
-            from ultralytics.utils.ops import scale_boxes as scale_coords # noqa
-            from ultralytics.data.augment import LetterBox
+            from ultralytics.utils.ops import scale_boxes as scale_coords # type: ignore # noqa
+            from ultralytics.data.augment import LetterBox # type: ignore # noqa
 
             # letterbox() became a LetterBox class in the ultralytics package.  Create a
             # backwards-compatible letterbox function wrapper that wraps the class up.
@@ -373,7 +410,7 @@ def _initialize_yolo_imports(model_type='yolov5',
                 else:
                     letterbox_transformer = LetterBox(new_shape,auto=auto,scale_fill=scaleFill,
                                                   scaleup=scaleup,center=center,stride=stride)
-                    
+
                 letterbox_result = letterbox_transformer(image=img)
 
                 if isinstance(new_shape,int):
@@ -516,6 +553,7 @@ def read_metadata_from_megadetector_model_file(model_file,
             archive from which we should read the metadata.  This is not relative to the root
             of the archive, it's relative to the one and only folder at the root of the archive
             (this is a PyTorch convention).
+        verbose (str, optional): enable additional debug output
 
     Returns:
         object: whatever we read from the metadata file, always a dict in practice.  Returns
@@ -575,7 +613,7 @@ class PTDetector:
 
         if verbose:
             print('Initializing PTDetector (verbose)')
-        
+
         # Set up the import environment for this model, unloading previous
         # YOLO library versions if necessary.
         _initialize_yolo_imports_for_model(model_path,
@@ -620,9 +658,9 @@ class PTDetector:
         #: aspect ratio".
         if model_metadata is not None and 'image_size' in model_metadata:
             self.default_image_size = model_metadata['image_size']
-            if verbose:
-                print('Loaded image size {} from model metadata'.format(self.default_image_size))
+            print('Loaded image size {} from model metadata'.format(self.default_image_size))
         else:
+            print('No image size available in model metadata, defaulting to 1280')
             self.default_image_size = 1280
 
         #: Either a string ('cpu','cuda:0') or a torch.device()
@@ -764,7 +802,7 @@ class PTDetector:
                 of the output object
             detection_threshold (float, optional): only detections above this confidence threshold
                 will be included in the return value
-            image_size (tuple, optional): image size to use for inference, only mess with this if
+            image_size (int, optional): image size to use for inference, only mess with this if
                 (a) you're using a model other than MegaDetector or (b) you know what you're getting into
             skip_image_resizing (bool, optional): whether to skip internal image resizing (and rely on
                 external resizing), only mess with this if (a) you're using a model other than MegaDetector