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

megadetector/detection/run_detector.py

@@ -32,6 +32,7 @@ import time
 import json
 import warnings
 import tempfile
+import zipfile
 
 import humanfriendly
 from tqdm import tqdm
@@ -40,6 +41,7 @@ from megadetector.utils import path_utils as path_utils
 from megadetector.visualization import visualization_utils as vis_utils
 from megadetector.utils.url_utils import download_url
 from megadetector.utils.ct_utils import parse_kvp_list
+from megadetector.utils.path_utils import compute_file_hash
 
 # ignoring all "PIL cannot read EXIF metainfo for the images" warnings
 warnings.filterwarnings('ignore', '(Possibly )?corrupt EXIF data', UserWarning)
@@ -81,29 +83,66 @@ USE_MODEL_NATIVE_CLASSES = False
 #
 # Order matters here.
 model_string_to_model_version = {
+
+    # Specific model versions that might be expressed in a variety of ways
     'mdv2':'v2.0.0',
     'mdv3':'v3.0.0',
     'mdv4':'v4.1.0',
-    'mdv5a':'v5a.0.0',
-    'mdv5b':'v5b.0.0',
+    'mdv5a':'v5a.0.1',
+    'mdv5b':'v5b.0.1',
+
     'v2':'v2.0.0',
     'v3':'v3.0.0',
     'v4':'v4.1.0',
     'v4.1':'v4.1.0',
-    'v5a.0.0':'v5a.0.0',
-    'v5b.0.0':'v5b.0.0',
+    'v5a.0.0':'v5a.0.1',
+    'v5b.0.0':'v5b.0.1',
+
+    'md1000-redwood':'v1000.0.0-redwood',
+    'md1000-cedar':'v1000.0.0-cedar',
+    'md1000-larch':'v1000.0.0-larch',
+    'md1000-sorrel':'v1000.0.0-sorrel',
+    'md1000-spruce':'v1000.0.0-spruce',
+
+    'mdv1000-redwood':'v1000.0.0-redwood',
+    'mdv1000-cedar':'v1000.0.0-cedar',
+    'mdv1000-larch':'v1000.0.0-larch',
+    'mdv1000-sorrel':'v1000.0.0-sorrel',
+    'mdv1000-spruce':'v1000.0.0-spruce',
+
+    'v1000-redwood':'v1000.0.0-redwood',
+    'v1000-cedar':'v1000.0.0-cedar',
+    'v1000-larch':'v1000.0.0-larch',
+    'v1000-sorrel':'v1000.0.0-sorrel',
+    'v1000-spruce':'v1000.0.0-spruce',
+
+    # Arguably less specific model versions
     'redwood':'v1000.0.0-redwood',
     'spruce':'v1000.0.0-spruce',
     'cedar':'v1000.0.0-cedar',
     'larch':'v1000.0.0-larch',
-    'default':'v5a.0.0',
-    'default-model':'v5a.0.0',
-    'megadetector':'v5a.0.0'
+
+    # Opinionated defaults
+    'mdv5':'v5a.0.1',
+    'md5':'v5a.0.1',
+    'mdv1000':'v1000.0.0-redwood',
+    'md1000':'v1000.0.0-redwood',
+    'default':'v5a.0.1',
+    'megadetector':'v5a.0.1',
 }
 
-model_url_base = 'http://localhost:8181/'
+# python -m http.server 8181
+model_url_base = 'https://github.com/agentmorris/MegaDetector/releases/download/v1000.0/'
 assert model_url_base.endswith('/')
 
+if os.environ.get('MD_MODEL_URL_BASE') is not None:
+    model_url_base = os.environ['MD_MODEL_URL_BASE']
+    print('Model URL base provided via environment variable: {}'.format(
+        model_url_base
+    ))
+    if not model_url_base.endswith('/'):
+        model_url_base += '/'
+
 # Maps canonical model version numbers to metadata
 known_models = {
     'v2.0.0':
@@ -137,7 +176,8 @@ known_models = {
         'conservative_detection_threshold':0.05,
         'image_size':1280,
         'model_type':'yolov5',
-        'normalized_typical_inference_speed':1.0
+        'normalized_typical_inference_speed':1.0,
+        'md5':'ec1d7603ec8cf642d6e0cd008ba2be8c'
     },
     'v5b.0.0':
     {
@@ -146,29 +186,58 @@ known_models = {
         'conservative_detection_threshold':0.05,
         'image_size':1280,
         'model_type':'yolov5',
-        'normalized_typical_inference_speed':1.0
+        'normalized_typical_inference_speed':1.0,
+        'md5':'bc235e73f53c5c95e66ea0d1b2cbf542'
+    },
+    'v5a.0.1':
+    {
+        'url':'https://github.com/agentmorris/MegaDetector/releases/download/v5.0/md_v5a.0.1.pt',
+        'typical_detection_threshold':0.2,
+        'conservative_detection_threshold':0.05,
+        'image_size':1280,
+        'model_type':'yolov5',
+        'normalized_typical_inference_speed':1.0,
+        'md5':'60f8e7ec1308554df258ed1f4040bc4f'
+    },
+    'v5b.0.1':
+    {
+        'url':'https://github.com/agentmorris/MegaDetector/releases/download/v5.0/md_v5b.0.1.pt',
+        'typical_detection_threshold':0.2,
+        'conservative_detection_threshold':0.05,
+        'image_size':1280,
+        'model_type':'yolov5',
+        'normalized_typical_inference_speed':1.0,
+        'md5':'f17ed6fedfac2e403606a08c89984905'
     },
-
-    # Fake values for testing
     'v1000.0.0-redwood':
     {
-        'normalized_typical_inference_speed':2.0,
-        'url':model_url_base + 'md_v1000.0.0-redwood.pt'
+        'url':model_url_base + 'md_v1000.0.0-redwood.pt',
+        'normalized_typical_inference_speed':1.0,
+        'md5':'74474b3aec9cf1a990da38b37ddf9197'
     },
     'v1000.0.0-spruce':
     {
-        'normalized_typical_inference_speed':3.0,
-        'url':model_url_base + 'md_v1000.0.0-spruce.pt'
+        'url':model_url_base + 'md_v1000.0.0-spruce.pt',
+        'normalized_typical_inference_speed':12.7,
+        'md5':'1c9d1d2b3ba54931881471fdd508e6f2'
     },
     'v1000.0.0-larch':
     {
-        'normalized_typical_inference_speed':4.0,
-        'url':model_url_base + 'md_v1000.0.0-larch.pt'
+        'url':model_url_base + 'md_v1000.0.0-larch.pt',
+        'normalized_typical_inference_speed':2.4,
+        'md5':'cab94ebd190c2278e12fb70ffd548b6d'
     },
     'v1000.0.0-cedar':
     {
-        'normalized_typical_inference_speed':5.0,
-        'url':model_url_base + 'md_v1000.0.0-cedar.pt'
+        'url':model_url_base + 'md_v1000.0.0-cedar.pt',
+        'normalized_typical_inference_speed':2.0,
+        'md5':'3d6472c9b95ba687b59ebe255f7c576b'
+    },
+    'v1000.0.0-sorrel':
+    {
+        'url':model_url_base + 'md_v1000.0.0-sorrel.pt',
+        'normalized_typical_inference_speed':7.0,
+        'md5':'4339a2c8af7a381f18ded7ac2a4df03e'
     }
 }
 
@@ -337,7 +406,8 @@ def get_detector_version_from_model_file(detector_filename,verbose=False):
 
         if version_string_based_on_filename != version_string_based_on_model_file:
             print(
-                'Warning: model version string in file:\n\n{}\n\n...is:\n\n{}\n\n...but the filename implies:\n\n{}'.format(
+                'Warning: model version string in file:' + \
+                 '\n\n{}\n\n...is:\n\n{}\n\n...but the filename implies:\n\n{}'.format(
                 os.path.basename(detector_filename),
                 version_string_based_on_model_file,
                 version_string_based_on_filename))
@@ -602,6 +672,7 @@ def load_and_run_detector(model_file,
             exists
         detector_options (dict, optional): key/value pairs that are interpreted differently
             by different detectors
+        verbose (bool, optional): enable additional debug output
     """
 
     if len(image_file_names) == 0:
@@ -707,7 +778,8 @@ def load_and_run_detector(model_file,
             time_infer.append(elapsed)
 
         except Exception as e:
-            print('An error occurred while running the detector on image {}: {}'.format(im_file, str(e)))
+            print('An error occurred while running the detector on image {}: {}'.format(
+                im_file, str(e)))
             continue
 
         try:
@@ -756,6 +828,55 @@ def load_and_run_detector(model_file,
 # ...def load_and_run_detector()
 
 
+def _validate_zip_file(file_path, file_description='file'):
+    """
+    Validates that a .pt file is a valid zip file.
+
+    Args:
+        file_path (str): path to the file to validate
+        file_description (str): descriptive string for error messages
+
+    Returns:
+        bool: True if valid, False otherwise
+    """
+    try:
+        with zipfile.ZipFile(file_path, 'r') as zipf:
+            zipf.testzip()
+        return True
+    except (zipfile.BadZipFile, zipfile.LargeZipFile) as e:
+        print('{} {} appears to be corrupted (bad zip): {}'.format(
+            file_description.capitalize(), file_path, str(e)))
+        return False
+    except Exception as e:
+        print('Error validating {}: {}'.format(file_description, str(e)))
+        return False
+
+
+def _validate_md5_hash(file_path, expected_hash, file_description='file'):
+    """
+    Validates that a file has the expected MD5 hash.
+
+    Args:
+        file_path (str): path to the file to validate
+        expected_hash (str): expected MD5 hash
+        file_description (str): descriptive string for error messages
+
+    Returns:
+        bool: True if hash matches, False otherwise
+    """
+    try:
+        actual_hash = compute_file_hash(file_path, algorithm='md5').lower()
+        expected_hash = expected_hash.lower()
+        if actual_hash != expected_hash:
+            print('{} {} has incorrect hash. Expected: {}, Actual: {}'.format(
+                file_description.capitalize(), file_path, expected_hash, actual_hash))
+            return False
+        return True
+    except Exception as e:
+        print('Error computing hash for {}: {}'.format(file_description, str(e)))
+        return False
+
+
 def _download_model(model_name,force_download=False):
     """
     Downloads one of the known models to local temp space if it hasn't already been downloaded.
@@ -782,13 +903,92 @@ def _download_model(model_name,force_download=False):
     if model_name.lower() not in known_models:
         print('Unrecognized downloadable model {}'.format(model_name))
         return None
-    url = known_models[model_name.lower()]['url']
+
+    model_info = known_models[model_name.lower()]
+    url = model_info['url']
     destination_filename = os.path.join(model_tempdir,url.split('/')[-1])
-    local_file = download_url(url, destination_filename=destination_filename, progress_updater=None,
-                     force_download=force_download, verbose=True)
+
+    # Check whether the file already exists, in which case we want to validate it
+    if os.path.exists(destination_filename) and not force_download:
+
+        # Only validate .pt files, not .pb files
+        if destination_filename.endswith('.pt'):
+
+            is_valid = True
+
+            # Check whether the file is a valid zip file (.pt files are zip files in disguise)
+            if not _validate_zip_file(destination_filename,
+                                      'existing model file'):
+                is_valid = False
+
+            # Check MD5 hash if available
+            if is_valid and \
+                ('md5' in model_info) and \
+                (model_info['md5'] is not None) and \
+                (len(model_info['md5'].strip()) > 0):
+
+                if not _validate_md5_hash(destination_filename, model_info['md5'],
+                                          'existing model file'):
+                    is_valid = False
+
+            # If validation failed, delete the corrupted file and re-download
+            if not is_valid:
+                print('Deleting corrupted model file and re-downloading: {}'.format(
+                    destination_filename))
+                try:
+                    os.remove(destination_filename)
+                    # This should be a no-op at this point, but it can't hurt
+                    force_download = True
+                except Exception as e:
+                    print('Warning: failed to delete corrupted file {}: {}'.format(
+                        destination_filename, str(e)))
+                    # Continue with download attempt anyway, setting force_download to True
+                    force_download = True
+            else:
+                print('Model {} already exists and is valid at {}'.format(
+                    model_name, destination_filename))
+                return destination_filename
+
+    # Download the model
+    try:
+        local_file = download_url(url,
+                                destination_filename=destination_filename,
+                                progress_updater=None,
+                                force_download=force_download,
+                                verbose=True)
+    except Exception as e:
+        print('Error downloading model {} from {}: {}'.format(model_name, url, str(e)))
+        raise
+
+    # Validate the downloaded file if it's a .pt file
+    if local_file and local_file.endswith('.pt'):
+
+        # Check if the downloaded file is a valid zip file
+        if not _validate_zip_file(local_file, "downloaded model file"):
+            # Clean up the corrupted download
+            try:
+                os.remove(local_file)
+            except Exception:
+                pass
+            return None
+
+        # Check MD5 hash if available
+        if ('md5' in model_info) and \
+            (model_info['md5'] is not None) and \
+            (len(model_info['md5'].strip()) > 0):
+
+            if not _validate_md5_hash(local_file, model_info['md5'], "downloaded model file"):
+                # Clean up the corrupted download
+                try:
+                    os.remove(local_file)
+                except Exception:
+                    pass
+                return None
+
     print('Model {} available at {}'.format(model_name,local_file))
     return local_file
 
+# ...def _download_model(...)
 
 def try_download_known_detector(detector_file,force_download=False,verbose=False):
     """

megadetector/detection/run_detector_batch.py

@@ -135,7 +135,9 @@ def _producer_func(q,
         assert isinstance(preprocessor,str)
         detector_options = deepcopy(detector_options)
         detector_options['preprocess_only'] = True
-        preprocessor = load_detector(preprocessor,detector_options=detector_options,verbose=verbose)
+        preprocessor = load_detector(preprocessor,
+                                     detector_options=detector_options,
+                                     verbose=verbose)
 
     for im_file in image_files:
 
@@ -209,7 +211,9 @@ def _consumer_func(q,
     start_time = time.time()
 
     if isinstance(model_file,str):
-        detector = load_detector(model_file,detector_options=detector_options,verbose=verbose)
+        detector = load_detector(model_file,
+                                 detector_options=detector_options,
+                                 verbose=verbose)
         elapsed = time.time() - start_time
         print('Loaded model (before queueing) in {}, printing updates every {} images'.format(
             humanfriendly.format_timespan(elapsed),n_queue_print))
@@ -323,7 +327,7 @@ def run_detector_with_image_queue(image_files,
         confidence_threshold (float): minimum confidence detection to include in
             output
         quiet (bool, optional): suppress per-image console printouts
-        image_size (tuple, optional): image size to use for inference, only mess with this
+        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
             doing
         include_image_size (bool, optional): should we include image size in the output for each image?
@@ -333,6 +337,8 @@ def run_detector_with_image_queue(image_files,
         detector_options (dict, optional): key/value pairs that are interpreted differently
             by different detectors
         loader_workers (int, optional): number of loaders to use
+        preprocess_on_image_queue (bool, optional): if the image queue is enabled, should it handle
+            image loading and preprocessing (True), or just image loading (False)?
 
     Returns:
         list: list of dicts in the format returned by process_image()
@@ -344,6 +350,9 @@ def run_detector_with_image_queue(image_files,
     if loader_workers <= 0:
         loader_workers = 1
 
+    if detector_options is None:
+        detector_options = {}
+
     q = multiprocessing.JoinableQueue(max_queue_size)
     return_queue = multiprocessing.Queue(1)
 
@@ -492,13 +501,13 @@ def process_images(im_files,
     Runs a detector (typically MegaDetector) over a list of image files on a single thread.
 
     Args:
-        im_files (list: paths to image files
+        im_files (list): paths to image files
         detector (str or detector object): loaded model or str; if this is a string, it can be a
             path to a .pb/.pt model file or a known model identifier (e.g. "MDV5A")
         confidence_threshold (float): only detections above this threshold are returned
         use_image_queue (bool, optional): separate image loading onto a dedicated worker process
         quiet (bool, optional): suppress per-image printouts
-        image_size (tuple, optional): image size to use for inference, only mess with this
+        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
             doing
         checkpoint_queue (Queue, optional): internal parameter used to pass image queues around
@@ -509,6 +518,8 @@ def process_images(im_files,
         detector_options (dict, optional): key/value pairs that are interpreted differently
             by different detectors
         loader_workers (int, optional): number of loaders to use (only relevant when using image queue)
+        preprocess_on_image_queue (bool, optional): if the image queue is enabled, should it handle
+            image loading and preprocessing (True), or just image loading (False)?
 
     Returns:
         list: list of dicts, in which each dict represents detections on one image,
@@ -518,10 +529,15 @@ def process_images(im_files,
     if isinstance(detector, str):
 
         start_time = time.time()
-        detector = load_detector(detector,detector_options=detector_options,verbose=verbose)
+        detector = load_detector(detector,
+                                 detector_options=detector_options,
+                                 verbose=verbose)
         elapsed = time.time() - start_time
         print('Loaded model (batch level) in {}'.format(humanfriendly.format_timespan(elapsed)))
 
+    if detector_options is None:
+        detector_options = {}
+
     if use_image_queue:
 
         run_detector_with_image_queue(im_files,
@@ -582,7 +598,7 @@ def process_image(im_file,
         image (Image, optional): previously-loaded image, if available, used when a worker
             thread is handling image loads
         quiet (bool, optional): suppress per-image printouts
-        image_size (tuple, optional): image size to use for inference, only mess with this
+        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
             doing
         include_image_size (bool, optional): should we include image size in the output for each image?
@@ -705,7 +721,7 @@ def load_and_run_detector_batch(model_file,
         image_file_names (list or str): list of strings (image filenames), a single image filename,
             a folder to recursively search for images in, or a .json or .txt file containing a list
             of images.
-        checkpoint_path (str, optional), path to use for checkpoints (if None, checkpointing
+        checkpoint_path (str, optional): path to use for checkpoints (if None, checkpointing
             is disabled)
         confidence_threshold (float, optional): only detections above this threshold are returned
         checkpoint_frequency (int, optional): int, write results to JSON checkpoint file every N
@@ -715,10 +731,10 @@ def load_and_run_detector_batch(model_file,
         n_cores (int, optional): number of parallel worker to use, ignored if we're running on a GPU
         use_image_queue (bool, optional): use a dedicated worker for image loading
         quiet (bool, optional): disable per-image console output
-        image_size (tuple, optional): image size to use for inference, only mess with this
+        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
             doing
-        class_mapping_filename (str, optional), use a non-default class mapping supplied in a .json
+        class_mapping_filename (str, optional): use a non-default class mapping supplied in a .json
             file or YOLOv5 dataset.yaml file
         include_image_size (bool, optional): should we include image size in the output for each image?
         include_image_timestamp (bool, optional): should we include image timestamps in the output for each image?
@@ -730,6 +746,8 @@ def load_and_run_detector_batch(model_file,
         detector_options (dict, optional): key/value pairs that are interpreted differently
             by different detectors
         loader_workers (int, optional): number of loaders to use, only relevant when use_image_queue is True
+        preprocess_on_image_queue (bool, optional): if the image queue is enabled, should it handle
+            image loading and preprocessing (True), or just image loading (False)?
 
     Returns:
         results: list of dicts; each dict represents detections on one image
@@ -739,6 +757,9 @@ def load_and_run_detector_batch(model_file,
     if n_cores is None or n_cores <= 0:
         n_cores = 1
 
+    if detector_options is None:
+        detector_options = {}
+
     if confidence_threshold is None:
         confidence_threshold=run_detector.DEFAULT_OUTPUT_CONFIDENCE_THRESHOLD
 
@@ -790,17 +811,19 @@ def load_and_run_detector_batch(model_file,
 
     already_processed = set([i['file'] for i in results])
 
-    model_file = try_download_known_detector(model_file, force_download=force_model_download)
+    model_file = try_download_known_detector(model_file,
+                                             force_download=force_model_download,
+                                             verbose=verbose)
 
     print('GPU available: {}'.format(is_gpu_available(model_file)))
 
-    if n_cores > 1 and is_gpu_available(model_file):
+    if (n_cores > 1) and is_gpu_available(model_file):
 
         print('Warning: multiple cores requested, but a GPU is available; parallelization across ' + \
               'GPUs is not currently supported, defaulting to one GPU')
         n_cores = 1
 
-    if n_cores > 1 and use_image_queue:
+    if (n_cores > 1) and use_image_queue:
 
         print('Warning: multiple cores requested, but the image queue is enabled; parallelization ' + \
               'with the image queue is not currently supported, defaulting to one worker')
@@ -830,7 +853,9 @@ def load_and_run_detector_batch(model_file,
 
         # Load the detector
         start_time = time.time()
-        detector = load_detector(model_file,detector_options=detector_options,verbose=verbose)
+        detector = load_detector(model_file,
+                                 detector_options=detector_options,
+                                 verbose=verbose)
         elapsed = time.time() - start_time
         print('Loaded model in {}'.format(humanfriendly.format_timespan(elapsed)))
 
@@ -1089,7 +1114,7 @@ def write_results_to_file(results,
 
         if detector_file is not None:
             detector_filename = os.path.basename(detector_file)
-            detector_version = get_detector_version_from_filename(detector_filename)
+            detector_version = get_detector_version_from_filename(detector_filename,verbose=True)
             detector_metadata = get_detector_metadata_from_version_string(detector_version)
             info['detector'] = detector_filename
             info['detector_metadata'] = detector_metadata
@@ -1409,7 +1434,8 @@ def main(): # noqa
     # If the specified detector file is really the name of a known model, find
     # (and possibly download) that model
     args.detector_file = try_download_known_detector(args.detector_file,
-                                                     force_download=args.force_model_download)
+                                                     force_download=args.force_model_download,
+                                                     verbose=verbose)
 
     assert os.path.exists(args.detector_file), \
         'detector file {} does not exist'.format(args.detector_file)

megadetector/detection/run_inference_with_yolov5_val.py

@@ -191,6 +191,10 @@ class YoloInferenceOptions:
         #: across calls, this can be set to False.
         self.append_job_id_to_symlink_folder = True
 
+        #: By default, we turn category ID 0 coming out of the YOLO .json file
+        #: into category 1 in the MD-formatted .json file.
+        self.offset_yolo_category_ids = True
+
     # ...def __init__()
 
 # ...YoloInferenceOptions()
@@ -225,7 +229,7 @@ def get_stats_for_category(filename,category='all'):
 
     Args:
         filename (str): a text file containing console output from a YOLO val run
-        category (optional, str): a category name
+        category (str, optional): a category name
 
     Returns:
         dict: a dict with fields n_images, n_labels, P, R, mAP50, and mAP50-95
@@ -957,7 +961,8 @@ def run_inference_with_yolo_val(options):
         yolo_category_id_to_name=options.yolo_category_id_to_name,
         detector_name=os.path.basename(model_filename),
         image_id_to_relative_path=image_id_to_relative_path,
-        image_id_to_error=image_id_to_error)
+        image_id_to_error=image_id_to_error,
+        offset_yolo_class_ids=options.offset_yolo_category_ids)
 
 
     ##%% Clean up
@@ -1058,6 +1063,9 @@ def main(): # noqa
     parser.add_argument(
         '--nonrecursive', action='store_true',
         help='disable recursive folder processing')
+    parser.add_argument(
+        '--no_offset_class_ids', action='store_true',
+        help='disable class ID offsetting')
 
     parser.add_argument(
         '--preview_yolo_command_only', action='store_true',
@@ -1113,6 +1121,7 @@ def main(): # noqa
     options.remove_yolo_results_folder = (not options.no_remove_yolo_results_folder)
     options.use_symlinks = (not options.no_use_symlinks)
     options.augment = (options.augment_enabled > 0)
+    options.offset_yolo_category_ids = (not options.no_offset_class_ids)
 
     del options.nonrecursive
     del options.no_remove_symlink_folder
@@ -1120,6 +1129,7 @@ def main(): # noqa
     del options.no_use_symlinks
     del options.augment_enabled
     del options.yolo_dataset_file
+    del options.no_offset_class_ids
 
     print(options.__dict__)
 

megadetector/detection/run_tiled_inference.py

@@ -447,6 +447,7 @@ def run_tiled_inference(model_file,
             run_inference_with_yolov5_val.py, rather than with run_detector_batch.py, using these options
         n_patch_extraction_workers (int, optional): number of workers to use for patch extraction;
             set to <= 1 to disable parallelization
+        overwrite_tiles (bool, optional): whether to overwrite image files for individual tiles if they exist
         image_list (list, optional): .json file containing a list of specific images to process.  If
             this is supplied, and the paths are absolute, [image_folder] will be ignored. If this is supplied,
             and the paths are relative, they should be relative to [image_folder]