megadetector 10.0.9__py3-none-any.whl → 10.0.11__py3-none-any.whl

megadetector/utils/wi_platform_utils.py

@@ -24,10 +24,14 @@ from multiprocessing.pool import Pool, ThreadPool
 from functools import partial
 
 from megadetector.utils.path_utils import insert_before_extension
+from megadetector.utils.path_utils import path_join
+
 from megadetector.utils.ct_utils import split_list_into_n_chunks
 from megadetector.utils.ct_utils import invert_dictionary
 from megadetector.utils.ct_utils import compare_values_nan_equal
 
+from megadetector.utils.string_utils import is_int
+
 from megadetector.utils.wi_taxonomy_utils import is_valid_prediction_string
 from megadetector.utils.wi_taxonomy_utils import no_cv_result_prediction_string
 from megadetector.utils.wi_taxonomy_utils import blank_prediction_string
@@ -68,7 +72,7 @@ def read_sequences_from_download_bundle(download_folder):
     assert len(sequence_list_files) == 1, \
         'Could not find sequences.csv in {}'.format(download_folder)
 
-    sequence_list_file = os.path.join(download_folder,sequence_list_files[0])
+    sequence_list_file = path_join(download_folder,sequence_list_files[0])
 
     df = pd.read_csv(sequence_list_file)
     sequence_records = df.to_dict('records')
@@ -104,7 +108,7 @@ def read_images_from_download_bundle(download_folder):
     image_list_files = \
         [fn for fn in image_list_files if fn.startswith('images_') and fn.endswith('.csv')]
     image_list_files = \
-        [os.path.join(download_folder,fn) for fn in image_list_files]
+        [path_join(download_folder,fn) for fn in image_list_files]
     print('Found {} image list files'.format(len(image_list_files)))
 
 
@@ -118,7 +122,7 @@ def read_images_from_download_bundle(download_folder):
         print('Reading images from list file {}'.format(
             os.path.basename(image_list_file)))
 
-        df = pd.read_csv(image_list_file)
+        df = pd.read_csv(image_list_file,low_memory=False)
 
         # i_row = 0; row = df.iloc[i_row]
         for i_row,row in tqdm(df.iterrows(),total=len(df)):
@@ -203,11 +207,91 @@ def find_images_in_identify_tab(download_folder_with_identify,download_folder_ex
 # ...def find_images_in_identify_tab(...)
 
 
-def write_download_commands(image_records_to_download,
+def write_prefix_download_command(image_records,
+                                  download_dir_base,
+                                  force_download=False,
+                                  download_command_file=None):
+    """
+    Write a .sh script to download all images (using gcloud) from the longest common URL
+    prefix in the images represented in [image_records].
+
+    Args:
+        image_records (list of dict): list of dicts with at least the field 'location'.
+            Can also be a dict whose values are lists of record dicts.
+        download_dir_base (str): local destination folder
+        force_download (bool, optional): overwrite existing files
+        download_command_file (str, optional): path of the .sh script we should write, defaults
+            to "download_wi_images_with_prefix.sh" in the destination folder.
+    """
+
+    ##%% Input validation
+
+    # If a dict is provided, assume it maps image GUIDs to lists of records, flatten to a list
+    if isinstance(image_records,dict):
+        all_image_records = []
+        for k in image_records:
+            records_this_image = image_records[k]
+            all_image_records.extend(records_this_image)
+        image_records = all_image_records
+
+    assert isinstance(image_records,list), \
+        'Illegal image record list format {}'.format(type(image_records))
+    assert isinstance(image_records[0],dict), \
+        'Illegal image record format {}'.format(type(image_records[0]))
+
+    urls = [r['location'] for r in image_records]
+
+    # "urls" is a list of URLs starting with gs://.  Find the highest-level folder
+    # that is common to all URLs in the list.  For example, if the list is:
+    #
+    # gs://a/b/c
+    # gs://a/b/d
+    #
+    # The result should be:
+    #
+    # gs://a/b
+    common_prefix = os.path.commonprefix(urls)
+
+    # Remove the gs:// prefix if it's still there
+    if common_prefix.startswith('gs://'):
+        common_prefix = common_prefix[len('gs://'):]
+
+    # Ensure the common prefix ends with a '/' if it's not empty
+    if (len(common_prefix) > 0) and (not common_prefix.endswith('/')):
+        common_prefix = os.path.dirname(common_prefix) + '/'
+
+    print('Longest common prefix: {}'.format(common_prefix))
+
+    if download_command_file is None:
+        download_command_file = \
+            path_join(download_dir_base,'download_wi_images_with_prefix.sh')
+
+    os.makedirs(download_dir_base,exist_ok=True)
+
+    with open(download_command_file,'w',newline='\n') as f:
+        # The --no-clobber flag prevents overwriting existing files
+        # The -r flag is for recursive download
+        # The gs:// prefix is added back for the gcloud command
+        no_clobber_string = ''
+        if not force_download:
+            no_clobber_string = '--no-clobber'
+
+        cmd = 'gcloud storage cp -r {} "gs://{}" "{}"'.format(
+            no_clobber_string,common_prefix,download_dir_base)
+        print('Writing download command:\n{}'.format(cmd))
+        f.write(cmd + '\n')
+
+    print('Download script written to {}'.format(download_command_file))
+
+# ...def write_prefix_download_command(...)
+
+
+def write_download_commands(image_records,
                             download_dir_base,
                             force_download=False,
                             n_download_workers=25,
-                            download_command_file_base=None):
+                            download_command_file_base=None,
+                            image_flattening='deployment'):
     """
     Given a list of dicts with at least the field 'location' (a gs:// URL), prepare a set of "gcloud
     storage" commands to download images, and write those to a series of .sh scripts, along with one
@@ -215,10 +299,9 @@ def write_download_commands(image_records_to_download,
 
     gcloud commands will use relative paths.
 
-    image_records_to_download can also be a dict mapping IDs to lists of records.
-
     Args:
-        image_records_to_download (list of dict): list of dicts with at least the field 'location'
+        image_records (list of dict): list of dicts with at least the field 'location'.
+            Can also be a dict whose values are lists of record dicts.
         download_dir_base (str): local destination folder
         force_download (bool, optional): include gs commands even if the target file exists
         n_download_workers (int, optional): number of scripts to write (that's our hacky way
@@ -226,42 +309,103 @@ def write_download_commands(image_records_to_download,
         download_command_file_base (str, optional): path of the .sh script we should write, defaults
             to "download_wi_images.sh" in the destination folder.  Individual worker scripts will
             have a number added, e.g. download_wi_images_00.sh.
+        image_flattening (str, optional): if 'none', relative paths will be preserved
+            representing the entire URL for each image.  Can be 'guid' (just download to
+            [GUID].JPG) or 'deployment' (download to [deployment]/[GUID].JPG).
     """
 
-    if isinstance(image_records_to_download,dict):
+    ##%% Input validation
 
+    # If a dict is provided, assume it maps image GUIDs to lists of records, flatten to a list
+    if isinstance(image_records,dict):
         all_image_records = []
-        for k in image_records_to_download:
-            records_this_image = image_records_to_download[k]
+        for k in image_records:
+            records_this_image = image_records[k]
             all_image_records.extend(records_this_image)
-        return write_download_commands(all_image_records,
-                                       download_dir_base=download_dir_base,
-                                       force_download=force_download,
-                                       n_download_workers=n_download_workers,
-                                       download_command_file_base=download_command_file_base)
+        image_records = all_image_records
+
+    assert isinstance(image_records,list), \
+        'Illegal image record list format {}'.format(type(image_records))
+    assert isinstance(image_records[0],dict), \
+        'Illegal image record format {}'.format(type(image_records[0]))
+
+
+    ##%% Map URLs to relative paths
+
+    # URLs look like:
+    #
+    # gs://145625555_2004881_2323_name__main/deployment/2241000/prod/directUpload/5fda0ddd-511e-46ca-95c1-302b3c71f8ea.JPG
+    if image_flattening is None:
+        image_flattening = 'none'
+    image_flattening = image_flattening.lower().strip()
+
+    assert image_flattening in ('none','guid','deployment'), \
+        'Illegal image flattening strategy {}'.format(image_flattening)
+
+    url_to_relative_path = {}
+
+    for image_record in image_records:
+
+        url = image_record['location']
+        assert url.startswith('gs://'), 'Illegal URL {}'.format(url)
+
+        relative_path = None
+
+        if image_flattening == 'none':
+            relative_path = url.replace('gs://','')
+        elif image_flattening == 'guid':
+            relative_path = url.split('/')[-1]
+        else:
+            assert image_flattening == 'deployment'
+            tokens = url.split('/')
+            found_deployment_id = False
+            for i_token,token in enumerate(tokens):
+                if token == 'deployment':
+                    assert i_token < (len(tokens)-1)
+                    deployment_id_string = tokens[i_token + 1]
+                    deployment_id_string = deployment_id_string.replace('_thumb','')
+                    assert is_int(deployment_id_string), \
+                        'Illegal deployment ID {}'.format(deployment_id_string)
+                    image_id = url.split('/')[-1]
+                    relative_path = deployment_id_string + '/' + image_id
+                    found_deployment_id = True
+                    break
+            assert found_deployment_id, \
+                'Could not find deployment ID in record {}'.format(str(image_record))
+
+        assert relative_path is not None
+
+        if url in url_to_relative_path:
+            assert url_to_relative_path[url] == relative_path, \
+                'URL path mapping error'
+        else:
+            url_to_relative_path[url] = relative_path
+
+    # ...for each image record
+
 
     ##%% Make list of gcloud storage commands
 
     if download_command_file_base is None:
-        download_command_file_base = os.path.join(download_dir_base,'download_wi_images.sh')
+        download_command_file_base = path_join(download_dir_base,'download_wi_images.sh')
 
     commands = []
     skipped_urls = []
     downloaded_urls = set()
 
-    # image_record = image_records_to_download[0]
-    for image_record in tqdm(image_records_to_download):
+    # image_record = image_records[0]
+    for image_record in tqdm(image_records):
 
         url = image_record['location']
         if url in downloaded_urls:
             continue
 
-        assert url.startswith('gs://')
+        assert url.startswith('gs://'), 'Illegal URL {}'.format(url)
 
-        relative_path = url.replace('gs://','')
-        abs_path = os.path.join(download_dir_base,relative_path)
+        relative_path = url_to_relative_path[url]
+        abs_path = path_join(download_dir_base,relative_path)
 
-        # Skip files that already exist
+        # Optionally skip files that already exist
         if (not force_download) and (os.path.isfile(abs_path)):
             skipped_urls.append(url)
             continue
@@ -271,7 +415,7 @@ def write_download_commands(image_records_to_download,
         commands.append(command)
 
     print('Generated {} commands for {} image records'.format(
-        len(commands),len(image_records_to_download)))
+        len(commands),len(image_records)))
 
     print('Skipped {} URLs'.format(len(skipped_urls)))
 

megadetector/utils/wi_taxonomy_utils.py

@@ -311,7 +311,8 @@ def taxonomy_info_to_taxonomy_string(taxonomy_info, include_taxon_id_and_common_
 def generate_whole_image_detections_for_classifications(classifications_json_file,
                                                         detections_json_file,
                                                         ensemble_json_file=None,
-                                                        ignore_blank_classifications=True):
+                                                        ignore_blank_classifications=True,
+                                                        verbose=True):
     """
     Given a set of classification results in SpeciesNet format that were likely run on
     already-cropped images, generate a file of [fake] detections in SpeciesNet format in which each
@@ -324,6 +325,7 @@ def generate_whole_image_detections_for_classifications(classifications_json_fil
             and classfications
         ignore_blank_classifications (bool, optional): use non-top classifications when
             the top classification is "blank" or "no CV result"
+        verbose (bool, optional): enable additional debug output
 
     Returns:
         dict: the contents of [detections_json_file]
@@ -336,16 +338,37 @@ def generate_whole_image_detections_for_classifications(classifications_json_fil
     output_predictions = []
     ensemble_predictions = []
 
-    # prediction = predictions[0]
-    for prediction in predictions:
+    # i_prediction = 0; prediction = predictions[i_prediction]
+    for i_prediction,prediction in enumerate(predictions):
 
         output_prediction = {}
         output_prediction['filepath'] = prediction['filepath']
         i_score = 0
+
         if ignore_blank_classifications:
+
             while (prediction['classifications']['classes'][i_score] in \
                    (blank_prediction_string,no_cv_result_prediction_string)):
+
                 i_score += 1
+                if (i_score >= len(prediction['classifications']['classes'])):
+
+                    if verbose:
+
+                        print('Ignoring blank classifications, but ' + \
+                              'image {} has no non-blank values'.format(
+                                i_prediction))
+
+                    # Just use the first one
+                    i_score = 0
+                    break
+
+                # ...if we passed the last prediction
+
+            # ...iterate over classes within this prediction
+
+        # ...if we're supposed to ignore blank classifications
+
         top_classification = prediction['classifications']['classes'][i_score]
         top_classification_score = prediction['classifications']['scores'][i_score]
         if is_animal_classification(top_classification):
@@ -450,8 +473,8 @@ def generate_md_results_from_predictions_json(predictions_json_file,
 
     # Round floating-point values (confidence scores, coordinates) to a
     # reasonable number of decimal places
-    if max_decimals is not None and max_decimals > 0:
-        round_floats_in_nested_dict(predictions)
+    if (max_decimals is not None) and (max_decimals > 0):
+        round_floats_in_nested_dict(predictions, decimal_places=max_decimals)
 
     predictions = predictions['predictions']
     assert isinstance(predictions,list)
@@ -714,7 +737,9 @@ def generate_predictions_json_from_md_results(md_results_file,
 
     # ...for each image
 
-    os.makedirs(os.path.dirname(predictions_json_file),exist_ok=True)
+    output_dir = os.path.dirname(predictions_json_file)
+    if len(output_dir) > 0:
+        os.makedirs(output_dir,exist_ok=True)
     with open(predictions_json_file,'w') as f:
         json.dump(output_dict,f,indent=1)
 
@@ -754,6 +779,7 @@ def generate_instances_json_from_folder(folder,
 
     assert os.path.isdir(folder)
 
+    print('Enumerating images in {}'.format(folder))
     image_files_abs = find_images(folder,recursive=True,return_relative_paths=False)
 
     if tokens_to_ignore is not None:
@@ -787,7 +813,9 @@ def generate_instances_json_from_folder(folder,
     to_return = {'instances':instances}
 
     if output_file is not None:
-        os.makedirs(os.path.dirname(output_file),exist_ok=True)
+        output_dir = os.path.dirname(output_file)
+        if len(output_dir) > 0:
+            os.makedirs(output_dir,exist_ok=True)
         with open(output_file,'w') as f:
             json.dump(to_return,f,indent=1)
 
@@ -869,7 +897,9 @@ def merge_prediction_json_files(input_prediction_files,output_prediction_file):
 
     output_dict = {'predictions':predictions}
 
-    os.makedirs(os.path.dirname(output_prediction_file),exist_ok=True)
+    output_dir = os.path.dirname(output_prediction_file)
+    if len(output_dir) > 0:
+        os.makedirs(output_dir,exist_ok=True)
     with open(output_prediction_file,'w') as f:
         json.dump(output_dict,f,indent=1)
 

megadetector/utils/write_html_image_list.py

@@ -110,7 +110,6 @@ def write_html_image_list(filename=None,images=None,options=None):
         if 'linkTarget' not in image_info:
             image_info['linkTarget'] = ''
         if 'textStyle' not in image_info:
-            text_style = options['defaultTextStyle']
             image_info['textStyle'] = options['defaultTextStyle']
         images[i_image] = image_info
 
@@ -185,7 +184,7 @@ def write_html_image_list(filename=None,images=None,options=None):
     if len(options['pageTitle']) > 0:
         title_string = '<title>{}</title>'.format(options['pageTitle'])
 
-    f_html.write('<html>{}<body>\n'.format(title_string))
+    f_html.write('<html><head>{}</head><body>\n'.format(title_string))
 
     f_html.write(options['headerHtml'])
 

megadetector/visualization/plot_utils.py

@@ -126,19 +126,16 @@ def plot_precision_recall_curve(precisions,
     ax.step(recalls, precisions, color='b', alpha=0.2, where='post')
     ax.fill_between(recalls, precisions, alpha=0.2, color='b', step='post')
 
-    try:
-        ax.set(x_label='Recall', y_label='Precision', title=title)
-        ax.set(x_lim=xlim, y_lim=ylim)
-    #
-    except Exception:
-        ax.set_xlabel('Recall')
-        ax.set_ylabel('Precision')
-        ax.set_title(title)
-        ax.set_xlim(xlim[0],xlim[1])
-        ax.set_ylim(ylim[0],ylim[1])
+    ax.set_xlabel('Recall')
+    ax.set_ylabel('Precision')
+    ax.set_title(title)
+    ax.set_xlim(xlim[0],xlim[1])
+    ax.set_ylim(ylim[0],ylim[1])
 
     return fig
 
+# ...def plot_precision_recall_curve(...)
+
 
 def plot_stacked_bar_chart(data,
                            series_labels=None,
@@ -174,17 +171,21 @@ def plot_stacked_bar_chart(data,
 
     # stacked bar charts are made with each segment starting from a y position
     cumulative_size = np.zeros(num_columns)
-    for i, row_data in enumerate(data):
-        ax.bar(ind, row_data, bottom=cumulative_size, label=series_labels[i],
-               color=colors[i])
+    for i_row, row_data in enumerate(data):
+        if series_labels is None:
+            label = 'series_{}'.format(str(i_row).zfill(2))
+        else:
+            label = series_labels[i_row]
+        ax.bar(ind, row_data, bottom=cumulative_size, label=label,
+               color=colors[i_row])
         cumulative_size += row_data
 
-    if col_labels and len(col_labels) < 25:
+    if (col_labels is not None) and (len(col_labels) < 25):
         ax.set_xticks(ind)
         ax.set_xticklabels(col_labels, rotation=90)
-    elif col_labels:
+    elif (col_labels is not None):
         ax.set_xticks(list(range(0, len(col_labels), 20)))
-        ax.set_xticklabels(col_labels, rotation=90)
+        ax.set_xticklabels(col_labels[::20], rotation=90)
 
     if x_label is not None:
         ax.set_xlabel(x_label)
@@ -202,6 +203,8 @@ def plot_stacked_bar_chart(data,
 
     return fig
 
+# ...def plot_stacked_bar_chart(...)
+
 
 def calibration_ece(true_scores, pred_scores, num_bins):
     r"""
@@ -245,10 +248,17 @@ def calibration_ece(true_scores, pred_scores, num_bins):
     ece = np.abs(accs - confs) @ weights
     return accs, confs, ece
 
+# ...def calibration_ece(...)
+
 
-def plot_calibration_curve(true_scores, pred_scores, num_bins,
-                           name='calibration', plot_perf=True, plot_hist=True,
-                           ax=None, **fig_kwargs):
+def plot_calibration_curve(true_scores,
+                           pred_scores,
+                           num_bins,
+                           name='calibration',
+                           plot_perf=True,
+                           plot_hist=True,
+                           ax=None,
+                           **fig_kwargs):
     """
     Plots a calibration curve.
 
@@ -295,3 +305,5 @@ def plot_calibration_curve(true_scores, pred_scores, num_bins,
         fig.legend(loc='upper left', bbox_to_anchor=(0.15, 0.85))
 
     return ax.figure
+
+# ...def plot_calibration_curve(...)

megadetector/visualization/render_images_with_thumbnails.py

@@ -185,6 +185,9 @@ def render_images_with_thumbnails(
     # ...for each crop
 
     # Write output image to disk
+    parent_dir = os.path.dirname(output_image_filename)
+    if len(parent_dir) > 0:
+        os.makedirs(parent_dir,exist_ok=True)
     output_image.save(output_image_filename)
 
 # ...def render_images_with_thumbnails(...)

megadetector/visualization/visualization_utils.py

@@ -1272,7 +1272,7 @@ def gray_scale_fraction(image,crop_size=(0.1,0.1)):
     if crop_size[0] > 0 or crop_size[1] > 0:
 
         assert (crop_size[0] + crop_size[1]) < 1.0, \
-            print('Illegal crop size: {}'.format(str(crop_size)))
+            'Illegal crop size: {}'.format(str(crop_size))
 
         top_crop_pixels = int(image.height * crop_size[0])
         bottom_crop_pixels = int(image.height * crop_size[1])
@@ -1391,7 +1391,9 @@ def _resize_absolute_image(input_output_files,
         status = 'error'
         error = str(e)
 
-    return {'input_fn':input_fn_abs,'output_fn':output_fn_abs,status:'status',
+    return {'input_fn':input_fn_abs,
+            'output_fn':output_fn_abs,
+            'status':status,
             'error':error}
 
 # ..._resize_absolute_image(...)
@@ -1460,6 +1462,7 @@ def resize_images(input_file_to_output_file,
         pool = None
 
         try:
+
             if pool_type == 'thread':
                 pool = ThreadPool(n_workers); poolstring = 'threads'
             else:
@@ -1477,10 +1480,13 @@ def resize_images(input_file_to_output_file,
                     quality=quality)
 
             results = list(tqdm(pool.imap(p, input_output_file_pairs),total=len(input_output_file_pairs)))
+
         finally:
-            pool.close()
-            pool.join()
-            print("Pool closed and joined for image resizing")
+
+            if pool is not None:
+                pool.close()
+                pool.join()
+                print('Pool closed and joined for image resizing')
 
     return results
 
@@ -1680,8 +1686,13 @@ def parallel_get_image_sizes(filenames,
         else:
             pool = Pool(n_workers)
 
-        results = list(tqdm(pool.imap(
-            partial(get_image_size,verbose=verbose),filenames), total=len(filenames)))
+        try:
+            results = list(tqdm(pool.imap(
+                partial(get_image_size,verbose=verbose),filenames), total=len(filenames)))
+        finally:
+            pool.close()
+            pool.join()
+            print('Pool closed and joined for image size retrieval')
 
     assert len(filenames) == len(results), 'Internal error in parallel_get_image_sizes'
 

megadetector/visualization/visualize_db.py

@@ -102,10 +102,6 @@ class DbVizOptions:
         #: :meta private:
         self.multiple_categories_tag = '*multiple*'
 
-        #: We sometimes flatten image directories by replacing a path separator with
-        #: another character.  Leave blank for the typical case where this isn't necessary.
-        self.pathsep_replacement = '' # '~'
-
         #: Parallelize rendering across multiple workers
         self.parallelize_rendering = False
 
@@ -141,24 +137,12 @@ class DbVizOptions:
         self.confidence_threshold = None
 
 
-#%% Helper functions
-
-def _image_filename_to_path(image_file_name, image_base_dir, pathsep_replacement=''):
-    """
-    Translates the file name in an image entry in the json database to a path, possibly doing
-    some manipulation of path separators.
-    """
-
-    if len(pathsep_replacement) > 0:
-        image_file_name = os.path.normpath(image_file_name).replace(os.pathsep,pathsep_replacement)
-    return os.path.join(image_base_dir, image_file_name)
-
-
 #%% Core functions
 
 def visualize_db(db_path, output_dir, image_base_dir, options=None):
     """
-    Writes images and html to output_dir to visualize the annotations in a .json file.
+    Writes images and html to output_dir to visualize the images and annotations in a
+    COCO-formatted .json file.
 
     Args:
         db_path (str or dict): the .json filename to load, or a previously-loaded database
@@ -176,9 +160,11 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
 
     # Consistency checking for fields with specific format requirements
 
-    # This should be a list, but if someone specifies a string, do a reasonable thing
+    # These should be a lists, but if someone specifies a string, do a reasonable thing
     if isinstance(options.extra_image_fields_to_print,str):
         options.extra_image_fields_to_print = [options.extra_image_fields_to_print]
+    if isinstance(options.extra_annotation_fields_to_print,str):
+        options.extra_annotation_fields_to_print = [options.extra_annotation_fields_to_print]
 
     if not options.parallelize_rendering_with_threads:
         print('Warning: process-based parallelization is not yet supported by visualize_db')
@@ -196,7 +182,7 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
         assert(os.path.isfile(db_path))
         print('Loading database from {}...'.format(db_path))
         image_db = json.load(open(db_path))
-        print('...done')
+        print('...done, loaded {} images'.format(len(image_db['images'])))
     elif isinstance(db_path,dict):
         print('Using previously-loaded DB')
         image_db = db_path
@@ -312,8 +298,7 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
         if image_base_dir.startswith('http'):
             img_path = image_base_dir + img_relative_path
         else:
-            img_path = os.path.join(image_base_dir,
-                                    _image_filename_to_path(img_relative_path, image_base_dir))
+            img_path = os.path.join(image_base_dir,img_relative_path).replace('\\','/')
 
         annos_i = df_anno.loc[df_anno['image_id'] == img_id, :] # all annotations on this image
 
@@ -407,7 +392,8 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
         img_id_string = str(img_id).lower()
         file_name = '{}_gt.jpg'.format(os.path.splitext(img_id_string)[0])
 
-        # Replace characters that muck up image links
+        # Replace characters that muck up image links, including flattening file
+        # separators.
         illegal_characters = ['/','\\',':','\t','#',' ','%']
         for c in illegal_characters:
             file_name = file_name.replace(c,'~')
@@ -625,9 +611,6 @@ def main():
                         help='Only include images with bounding boxes (defaults to false)')
     parser.add_argument('--random_seed', action='store', type=int, default=None,
                         help='Random seed for image selection')
-    parser.add_argument('--pathsep_replacement', action='store', type=str, default='',
-                        help='Replace path separators in relative filenames with another ' + \
-                             'character (frequently ~)')
 
     if len(sys.argv[1:]) == 0:
         parser.print_help()

megadetector/visualization/visualize_detector_output.py

@@ -428,6 +428,7 @@ def main(): # noqa
         category_names_to_blur=category_names_to_blur)
 
     if (args.html_output_file is not None) and args.open_html_output_file:
+        print('Opening output file {}'.format(args.html_output_file))
         open_file(args.html_output_file)
 
 if __name__ == '__main__':