megadetector 5.0.25__py3-none-any.whl → 5.0.27__py3-none-any.whl

megadetector/utils/wi_utils.py

@@ -84,6 +84,105 @@ def is_valid_taxonomy_string(s):
     return isinstance(s,str) and (len(s.split(';')) == 5) and (s == s.lower())
 
     
+def clean_taxonomy_string(s):
+    """
+    If [s] is a seven-token prediction string, trim the GUID and common name to produce
+    a "clean" taxonomy string.  Else if [s] is a five-token string, return it.  Else error.
+
+    Args:
+        s (str): the seven- or five-token taxonomy/prediction string to clean
+    
+    Returns:
+        str: the five-token taxonomy string
+    """
+    
+    if is_valid_taxonomy_string(s):
+        return s
+    elif is_valid_prediction_string(s):        
+        tokens = s.split(';')
+        assert len(tokens) == 7
+        return ';'.join(tokens[1:-1])
+    else:
+        raise ValueError('Invalid taxonomy string')
+    
+
+taxonomy_level_names = \
+    ['non-taxonomic','kingdom','phylum','class','order','family','genus','species','subspecies']
+
+
+def taxonomy_level_to_string(k):
+    """
+    Maps taxonomy level indices (0 for kindgom, 1 for phylum, etc.) to strings.
+    
+    Args:
+        k (int): taxonomy level index
+    
+    Returns:
+        str: taxonomy level string
+    """
+    
+    assert k >= 0 and k < len(taxonomy_level_names), \
+        'Illegal taxonomy level index {}'.format(k)
+        
+    return taxonomy_level_names[k]
+
+
+def taxonomy_level_string_to_index(s):
+    """
+    Maps strings ('kingdom', 'species', etc.) to level indices.
+    
+    Args:
+        s (str): taxonomy level string
+    
+    Returns:
+        int: taxonomy level index
+    """
+    
+    assert s in taxonomy_level_names, 'Unrecognized taxonomy level string {}'.format(s)
+    return taxonomy_level_names.index(s)
+    
+
+def taxonomy_level_index(s):
+    """
+    Returns the taxonomy level up to which [s] is defined (0 for non-taxnomic, 1 for kingdom,
+    2 for phylum, etc.  Empty strings and non-taxonomic strings are treated as level 0.  1 and 2
+    will never be returned; "animal" doesn't look like other taxonomic strings, so here we treat
+    it as non-taxonomic.
+    
+    Args:
+        s (str): 5-token or 7-token taxonomy string
+    
+    Returns:
+        int: taxonomy level
+    """
+    
+    if s in non_taxonomic_prediction_strings or s in non_taxonomic_prediction_short_strings:
+        return 0
+    
+    tokens = s.split(';')
+    assert len(tokens) in (5,7)
+    
+    if len(tokens) == 7:
+        tokens = tokens[1:-1]
+    
+    if len(tokens[0]) == 0:
+        return 0
+    # WI taxonomy strings start at class, so we'll never return 1 (kingdom) or 2 (phylum)
+    elif len(tokens[1]) == 0:
+        return 3
+    elif len(tokens[2]) == 0:
+        return 4
+    elif len(tokens[3]) == 0:
+        return 5
+    elif len(tokens[4]) == 0:
+        return 6
+    # Subspecies are delimited with a space
+    elif ' ' not in tokens[4]:
+        return 7
+    else: 
+        return 8
+        
+    
 def wi_result_to_prediction_string(r):
     """
     Convert the dict [r] - typically loaded from a row in a downloaded .csv file - to
@@ -500,6 +599,10 @@ non_taxonomic_prediction_strings = [blank_prediction_string,
                                     animal_prediction_string,
                                     vehicle_prediction_string]
 
+non_taxonomic_prediction_short_strings = [';'.join(s.split(';')[1:-1]) for s in \
+                                          non_taxonomic_prediction_strings]
+
+
 process_cv_response_url = 'https://placeholder'
 
 
@@ -912,6 +1015,19 @@ def is_human_classification(prediction_string):
         bool: whether this string corresponds to a human category
     """
     return prediction_string == human_prediction_string or 'homo;sapiens' in prediction_string
+
+
+def is_vehicle_classification(prediction_string):
+    """
+    Determines whether the input string represents a vehicle classification.
+    
+    Args:
+        prediction_string (str): a string in the semicolon-delimited prediction string format
+        
+    Returns:
+        bool: whether this string corresponds to the vehicle category
+    """
+    return prediction_string == vehicle_prediction_string
     
 
 def is_animal_classification(prediction_string):
@@ -939,17 +1055,114 @@ def is_animal_classification(prediction_string):
     return True
 
 
+def generate_whole_image_detections_for_classifications(classifications_json_file,
+                                                        detections_json_file,
+                                                        ensemble_json_file=None,
+                                                        ignore_blank_classifications=True):
+    """
+    Given a set of classification results that were likely run on already-cropped
+    image, generate a file of [fake] detections in which each image is covered
+    in a single whole-image detection.
+    
+    Args:
+        classifications_json_file (str): SpeciesNet-formatted file containing classifications 
+        detections_json_file (str): SpeciesNet-formatted file to write with detections
+        ensemble_json_file (str, optional): SpeciesNet-formatted file to write with detections 
+            and classfications
+        ignore_blank_classifications (bool, optional): use non-top classifications when
+            the top classification is "blank" or "no CV result"
+    
+    Returns:
+        dict: the contents of [detections_json_file]
+    """
+    
+    with open(classifications_json_file,'r') as f:
+        classification_results = json.load(f)
+    predictions = classification_results['predictions']
+    
+    output_predictions = []
+    ensemble_predictions = []
+    
+    # prediction = predictions[0]
+    for prediction in 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
+        top_classification = prediction['classifications']['classes'][i_score]
+        top_classification_score = prediction['classifications']['scores'][i_score]
+        if is_animal_classification(top_classification):
+            category_name = 'animal'
+        elif is_human_classification(top_classification):
+            category_name = 'human'
+        else:
+            category_name = 'vehicle'
+        
+        if category_name == 'human':
+            md_category_name = 'person'
+        else:
+            md_category_name = category_name
+            
+        output_detection = {}
+        output_detection['label'] = category_name
+        output_detection['category'] = md_category_name_to_id[md_category_name]
+        output_detection['conf'] = 1.0
+        output_detection['bbox'] = [0.0, 0.0, 1.0, 1.0]
+        output_prediction['detections'] = [output_detection]
+        output_predictions.append(output_prediction)        
+        
+        ensemble_prediction = {}
+        ensemble_prediction['filepath'] = prediction['filepath']
+        ensemble_prediction['detections'] = [output_detection]
+        ensemble_prediction['prediction'] = top_classification
+        ensemble_prediction['prediction_score'] = top_classification_score
+        ensemble_prediction['prediction_source'] = 'fake_ensemble_file_utility'
+        ensemble_prediction['classifications'] = prediction['classifications']
+        ensemble_predictions.append(ensemble_prediction)
+
+    # ...for each image
+        
+    ## Write output
+        
+    if ensemble_json_file is not None:
+        
+        ensemble_output_data = {'predictions':ensemble_predictions}
+        with open(ensemble_json_file,'w') as f:
+            json.dump(ensemble_output_data,f,indent=1)    
+        _ = validate_predictions_file(ensemble_json_file)
+    
+    output_data = {'predictions':output_predictions}
+    with open(detections_json_file,'w') as f:
+        json.dump(output_data,f,indent=1)
+    return validate_predictions_file(detections_json_file)
+    
+# ...def generate_whole_image_detections_for_classifications(...)        
+
+
 def generate_md_results_from_predictions_json(predictions_json_file,
                                               md_results_file,
                                               base_folder=None,
-                                              max_decimals=5):
+                                              max_decimals=5,
+                                              convert_human_to_person=True):
     """
-    Generate an MD-formatted .json file from a predictions.json file.  Typically,
-    MD results files use relative paths, and predictions.json files use absolute paths, so 
-    this function optionally removes the leading string [base_folder] from all file names.
+    Generate an MD-formatted .json file from a predictions.json file, generated by the 
+    SpeciesNet ensemble.  Typically, MD results files use relative paths, and predictions.json 
+    files use absolute paths, so this function optionally removes the leading string 
+    [base_folder] from all file names.
+    
+    Currently just applies the top classification category to every detection.  If the top 
+    classification is "blank", writes an empty detection list.
+    
+    Uses the classification from the "prediction" field if it's available, otherwise 
+    uses the "classifications" field.
     
-    Currently just applies the top classification category to every detection.  If the top classification 
-    is "blank", writes an empty detection list.
+    When using the "prediction" field, records the top class in the "classifications" field to 
+    a field in each image called "top_classification_common_name".  This is often different 
+    from the value of  the "prediction" field.
     
     speciesnet_to_md.py is a command-line driver for this function.
     
@@ -960,6 +1173,9 @@ def generate_md_results_from_predictions_json(predictions_json_file,
             predictions.json file
         max_decimals (int, optional): number of decimal places to which we should round
             all values
+        convert_human_to_person (bool, optional): WI predictions.json files sometimes use the
+            detection category "human"; MD files usually use "person".  If True, switches "human"
+            to "person".
     """
         
     # Read predictions file    
@@ -1040,7 +1256,8 @@ def generate_md_results_from_predictions_json(predictions_json_file,
             # ...if detections are present
             
             class_to_assign = None
-            class_confidence = None
+            class_confidence = None            
+            top_classification_common_name = None
             
             if 'classifications' in im_in:
                 
@@ -1050,8 +1267,15 @@ def generate_md_results_from_predictions_json(predictions_json_file,
                 class_to_assign = classifications['classes'][0]
                 class_confidence = classifications['scores'][0]
                 
+                tokens = class_to_assign.split(';')
+                assert len(tokens) == 7
+                top_classification_common_name = tokens[-1]
+                if len(top_classification_common_name) == 0:
+                    top_classification_common_name = 'undefined'
+                
             if 'prediction' in im_in:
                 
+                im_out['top_classification_common_name'] = top_classification_common_name
                 class_to_assign = im_in['prediction']
                 class_confidence = im_in['prediction_score']
             
@@ -1111,8 +1335,7 @@ def generate_md_results_from_predictions_json(predictions_json_file,
             print('Warning: you supplied {} as the base folder, but I made zero replacements'.format(
                 base_folder))
             
-    # Fix the 'unknown' category
-    
+    # Fix the 'unknown' category    
     if len(all_unknown_detections) > 0:
         
         max_detection_category_id = max([int(x) for x in detection_category_id_to_name.keys()])
@@ -1144,6 +1367,11 @@ def generate_md_results_from_predictions_json(predictions_json_file,
     info['format_version'] = 1.4
     info['detector'] = 'converted_from_predictions_json'
     
+    if convert_human_to_person:
+        for k in detection_categories_out.keys():
+            if detection_categories_out[k] == 'human':
+                detection_categories_out[k] = 'person'
+                    
     output_dict = {}
     output_dict['info'] = info
     output_dict['detection_categories'] = detection_categories_out
@@ -1223,6 +1451,7 @@ def generate_predictions_json_from_md_results(md_results_file,
         
 # ...def generate_predictions_json_from_md_results(...)
 
+
 default_tokens_to_ignore = ['$RECYCLE.BIN']
 
 def generate_instances_json_from_folder(folder,
@@ -1403,7 +1632,7 @@ def validate_predictions_file(fn,instances=None,verbose=True):
             failures.append(im)
 
     if verbose:
-        print('Read detector results for {} images, with {} failure(s)'.format(
+        print('Read predictions for {} images, with {} failure(s)'.format(
             len(d['predictions']),len(failures)))
         
     if instances is not None:
@@ -1454,6 +1683,7 @@ def find_geofence_adjustments(ensemble_json_file,use_latin_names=False):
             descending order by count.
     """
     
+    # Load and validate ensemble results
     ensemble_results = validate_predictions_file(ensemble_json_file)
     
     assert isinstance(ensemble_results,dict)
@@ -1510,14 +1740,56 @@ def find_geofence_adjustments(ensemble_json_file,use_latin_names=False):
 # ...def find_geofence_adjustments(...)    
 
 
+def generate_geofence_adjustment_html_summary(rollup_pair_to_count,min_count=10):
+    """
+    Given a list of geofence rollups, likely generated by find_geofence_adjustments,
+    generate an HTML summary of the changes made by geofencing.  The resulting HTML
+    is wrapped in <div>, but not, for example, in <html> or <body>.
+    
+    Args:
+        rollup_pair_to_count (dict): list of changes made by geofencing, see 
+            find_geofence_adjustments for details
+        min_count (int, optional): minimum number of changes a pair needs in order
+            to be included in the report.
+    """
+    
+    geofence_footer = ''
+
+    # Restrict to the list of taxa that were impacted by geofencing
+    rollup_pair_to_count = \
+        {key: value for key, value in rollup_pair_to_count.items() if value >= min_count}
+
+    # rollup_pair_to_count is sorted in descending order by count
+    assert is_list_sorted(list(rollup_pair_to_count.values()),reverse=True)
+
+    if len(rollup_pair_to_count) > 0:
+        
+        geofence_footer = \
+            '<h3>Geofence changes that occurred more than {} times</h3>\n'.format(min_count)
+        geofence_footer += '<div class="contentdiv">\n'
+        
+        print('\nRollup changes with count > {}:'.format(min_count))
+        for rollup_pair in rollup_pair_to_count.keys():
+            count = rollup_pair_to_count[rollup_pair]
+            rollup_pair_s = rollup_pair.replace(',',' --> ')
+            print('{}: {}'.format(rollup_pair_s,count))
+            rollup_pair_html = rollup_pair.replace(',',' &rarr; ')
+            geofence_footer += '{} ({})<br/>\n'.format(rollup_pair_html,count)
+
+        geofence_footer += '</div>\n'
+
+    return geofence_footer
+
+# ...def generate_geofence_adjustment_html_summary(...)
+
+
 #%% Module-level globals related to taxonomy mapping and geofencing    
 
 # This maps a taxonomy string (e.g. mammalia;cetartiodactyla;cervidae;odocoileus;virginianus) to 
 # a dict with keys taxon_id, common_name, kingdom, phylum, class, order, family, genus, species
 taxonomy_string_to_taxonomy_info = None
 
-# Maps a binomial name (possibly three tokens, if it's a subspecies) to the same dict
-# described above.
+# Maps a binomial name (one, two, or three ws-delimited tokens) to the same dict described above.
 binomial_name_to_taxonomy_info = None
 
 # Maps a common name to the same dict described above
@@ -1627,17 +1899,28 @@ def initialize_taxonomy_info(taxonomy_file,force_init=False,encoding='cp1252'):
             common_name_to_taxonomy_info[taxon_info['common_name']] = taxon_info
             
         taxonomy_string_to_taxonomy_info[taxonomy_string] = taxon_info
-        if tokens[4] == '' or tokens[5] == '':
+        
+        binomial_name = None
+        if len(tokens[4]) > 0 and len(tokens[5]) > 0:
+            # strip(), but don't remove spaces from the species name; 
+            # subspecies are separated with a space, e.g. canis;lupus dingo
+            binomial_name = tokens[4].strip() + ' ' + tokens[5].strip()            
+        elif len(tokens[4]) > 0:
+            binomial_name = tokens[4].strip()
+        elif len(tokens[3]) > 0:
+            binomial_name = tokens[3].strip()
+        elif len(tokens[2]) > 0:
+            binomial_name = tokens[2].strip()
+        elif len(tokens[1]) > 0:
+            binomial_name = tokens[1].strip()
+        if binomial_name is None:
             # print('Warning: no binomial name for {}'.format(taxonomy_string))
             pass
         else:
-            # strip(), but don't remove spaces from the species name; 
-            # subspecies are separated with a space, e.g. canis;lupus dingo
-            binomial_name = tokens[4].strip() + ' ' + tokens[5].strip()
             binomial_name_to_taxonomy_info[binomial_name] = taxon_info
     
-    print('Created {} records in taxonomy_string_to_taxonomy_info'.format(
-        len(taxonomy_string_to_taxonomy_info)))
+    print('Created {} records in taxonomy_string_to_taxonomy_info'.format(len(taxonomy_string_to_taxonomy_info)))
+    print('Created {} records in common_name_to_taxonomy_info'.format(len(common_name_to_taxonomy_info)))
         
 # ...def initialize_taxonomy_info(...)
 
@@ -1741,7 +2024,7 @@ def generate_csv_rows_for_species(species_string,
     and blocking a country.
     
     Args:
-        species_string (str): string in semicolon-delimited WI taxonomy format
+        species_string (str): five-token string in semicolon-delimited WI taxonomy format
         allow_countries (optional, list or str): three-letter country codes, list of
             country codes, or comma-separated list of country codes to allow
         block_countries (optional, list or str): three-letter country codes, list of
@@ -1849,23 +2132,21 @@ def initialize_geofencing(geofencing_file,country_code_file,force_init=False):
         
         species_rules = taxonomy_string_to_geofencing_rules[species_string]
         
-        # Every country should *either* have allow rules or block rules, no countries 
-        # currently have both        
-        assert len(species_rules.keys()) == 1
-        rule_type = list(species_rules.keys())[0]
-        assert rule_type in ('allow','block')
-
-        all_country_rules_this_species = species_rules[rule_type]
-        for country_code in all_country_rules_this_species.keys():
-            
-            assert country_code in country_code_to_country
+        if len(species_rules.keys()) > 1:
+            print('Warning: taxon {} has both allow and block rules'.format(species_string))
         
-            region_rules = all_country_rules_this_species[country_code]
+        for rule_type in species_rules.keys():
+            
+            assert rule_type in ('allow','block')    
+            all_country_rules_this_species = species_rules[rule_type]
             
-            # Right now we only have regional rules for the USA; these may be part of 
-            # allow or block rules.
-            if len(region_rules) > 0:
-                assert country_code == 'USA'
+            for country_code in all_country_rules_this_species.keys():            
+                assert country_code in country_code_to_country            
+                region_rules = all_country_rules_this_species[country_code]                
+                # Right now we only have regional rules for the USA; these may be part of 
+                # allow or block rules.
+                if len(region_rules) > 0:
+                    assert country_code == 'USA'
     
     # ...for each species
     
@@ -1875,7 +2156,7 @@ def initialize_geofencing(geofencing_file,country_code_file,force_init=False):
 def _species_string_to_canonical_species_string(species):
     """
     Convert a string that may be a 5-token species string, a binomial name,
-    or a common name into a 5-token species string.
+    or a common name into a 5-token species string, using taxonomic lookup.
     """
     
     global taxonomy_string_to_taxonomy_info
@@ -1894,14 +2175,14 @@ def _species_string_to_canonical_species_string(species):
     # If this is already a taxonomy string...    
     if len(species.split(';')) == 5:
         pass
-    # If this is a binomial name (which may include a subspecies)...
-    elif (len(species.split(' ')) in (2,3)) and (species in binomial_name_to_taxonomy_info):
-        taxonomy_info = binomial_name_to_taxonomy_info[species]
-        taxonomy_string = taxonomy_info_to_taxonomy_string(taxonomy_info)        
     # If this is a common name...
     elif species in common_name_to_taxonomy_info:
         taxonomy_info = common_name_to_taxonomy_info[species]
         taxonomy_string = taxonomy_info_to_taxonomy_string(taxonomy_info)        
+    # If this is a binomial name...
+    elif (species in binomial_name_to_taxonomy_info):
+        taxonomy_info = binomial_name_to_taxonomy_info[species]
+        taxonomy_string = taxonomy_info_to_taxonomy_string(taxonomy_info)        
     else:
         raise ValueError('Could not find taxonomic information for {}'.format(species))
         
@@ -1966,29 +2247,34 @@ def species_allowed_in_country(species,country,state=None,return_status=False):
     allowed_countries = []
     blocked_countries = []
     
-    assert len(geofencing_rules_this_species.keys()) == 1
-    rule_type = list(geofencing_rules_this_species.keys())[0]
-    assert rule_type in ('allow','block')
+    rule_types_this_species = list(geofencing_rules_this_species.keys())
+    for rule_type in rule_types_this_species:
+        assert rule_type in ('allow','block')
     
-    if rule_type == 'allow':    
-        allowed_countries = list(geofencing_rules_this_species['allow'])
-    else:
-        assert rule_type == 'block'
+    if 'block' in rule_types_this_species:
         blocked_countries = list(geofencing_rules_this_species['block'])
+    if 'allow' in rule_types_this_species:
+        allowed_countries = list(geofencing_rules_this_species['allow'])    
     
     status = None
     
     # The convention is that block rules win over allow rules
     if country_code in blocked_countries:
-        status = 'blocked'
+        if country_code in allowed_countries:
+            status = 'blocked_over_allow'
+        else:
+            status = 'blocked'
     elif country_code in allowed_countries:
         status = 'allowed'
-    else:
+    elif len(allowed_countries) > 0:
         # The convention is that if allow rules exist, any country not on that list
         # is blocked.
-        assert len(allowed_countries) > 0
-        return 'not_on_country_allow_list'
-    
+        status = 'block_not_on_country_allow_list'
+    else:
+        # Only block rules exist for this species, and they don't include this country
+        assert len(blocked_countries) > 0
+        status = 'allow_not_on_block_list'
+        
     # Now let's see whether we have to deal with any regional rules
     if state is None:
         
@@ -2441,16 +2727,18 @@ if False:
 
     from megadetector.utils.wi_utils import taxonomy_string_to_geofencing_rules # noqa
     from megadetector.utils.wi_utils import taxonomy_string_to_taxonomy_info # noqa
+    from megadetector.utils.wi_utils import common_name_to_taxonomy_info # noqa
+    from megadetector.utils.wi_utils import binomial_name_to_taxonomy_info # noqa
     
-    geofencing_file = r'c:\git\cameratrapai\data\geofence_base.json'
-    
-    country_code_file = r'g:\temp\country-codes.csv'
+    model_base = os.path.expanduser('~/models/speciesnet')
+    geofencing_file = os.path.join(model_base,'crop','geofence_release.2025.02.27.0702.json')
+    country_code_file = os.path.join(model_base,'country-codes.csv')
     # encoding = 'cp1252'; taxonomy_file = r'g:\temp\taxonomy_mapping-' + encoding + '.json'    
-    encoding = None; taxonomy_file = r'g:\temp\taxonomy_mapping.json'
+    encoding = None; taxonomy_file = os.path.join(model_base,'taxonomy_mapping.json')
     
     initialize_geofencing(geofencing_file, country_code_file, force_init=True)
     initialize_taxonomy_info(taxonomy_file, force_init=True, encoding=encoding)
-    
+        
     
     #%% Test driver for geofence_fixes.csv function
     
@@ -2458,21 +2746,26 @@ if False:
     species = 'dingo'
     species_string = _species_string_to_canonical_species_string(species)
     rows = _generate_csv_rows_to_block_all_countries_except(species_string,block_except_list)
-        
-    import clipboard; clipboard.copy('\n'.join(rows))
+    
+    # import clipboard; clipboard.copy('\n'.join(rows))
+    print(rows)
     
     
     #%%
     
-    generate_csv_rows_for_species(species_string=species_string,
-                                  allow_countries=None,
+    taxon_name = 'hippopotamus amphibius'
+    taxonomy_info = binomial_name_to_taxonomy_info[taxon_name]    
+    taxonomy_string_short = taxonomy_info_to_taxonomy_string(taxonomy_info)
+    assert len(taxonomy_string_short.split(';')) == 5
+    
+    generate_csv_rows_for_species(species_string=taxonomy_string_short,
+                                  allow_countries=['COL'],
                                   block_countries=None,
                                   allow_states=None,
                                   block_states=None,
                                   blockexcept_countries=None)
-    
-    
-    _generate_csv_rows_to_block_all_countries_except(species_string,'AUS')
+        
+    # _generate_csv_rows_to_block_all_countries_except(species_string,'AUS')
     
     
     #%% Test the effects of geofence changes
@@ -2482,51 +2775,18 @@ if False:
     species_allowed_in_country(species,country,state=None,return_status=False)
         
     
-    #%% instances.json generation test
+    #%% Geofencing lookups
     
-    from megadetector.utils.wi_utils import generate_instances_json_from_folder # noqa
-    
-    instances_file = r'g:\temp\water-hole\instances.json'
-    
-    _ = generate_instances_json_from_folder(folder=r'g:\temp\water-hole',
-                                            country='NAM',
-                                            lat=None,
-                                            lon=None,
-                                            output_file=instances_file,
-                                            filename_replacements={'g:/temp':'/mnt/g/temp'})
-
-    # from megadetector.utils.path_utils import open_file; open_file(instances_file)
-
-
-    #%% MD --> prediction conversion test
+    # This can be a latin or common name
+    species = 'hippopotamidae'
+    # print(common_name_to_taxonomy_info[species])
     
-    from megadetector.utils.wi_utils import generate_predictions_json_from_md_results # noqa
-    md_results_file = r'G:\temp\md-test-images\mdv5a.relpaths.json'
-    predictions_json_file = r'\\wsl$\Ubuntu\home\dmorris\tmp\speciesnet-tests\mdv5a.abspaths.predictions-format.json'
-    generate_predictions_json_from_md_results(md_results_file,predictions_json_file,base_folder=
-                                              '/home/dmorris/tmp/md-test-images/')
-    
-    from megadetector.utils.wi_utils import generate_predictions_json_from_md_results # noqa
-    md_results_file = r"G:\temp\water-hole\md_results.json"
-    predictions_json_file = r"G:\temp\water-hole\md_results-prediction_format.json"
-    generate_predictions_json_from_md_results(md_results_file,predictions_json_file,base_folder=
-                                              '/mnt/g/temp/water-hole')    
-    
-    
-    #%% Geofencing tests
-    
-    species = 'didelphis marsupialis'
-    print(binomial_name_to_taxonomy_info[species])
-    country = 'Guatemala'
-    assert species_allowed_in_country(species, country)
-    
-    species = 'virginia opossum'
-    print(common_name_to_taxonomy_info[species])
+    # This can be a name or country code
     country = 'USA'
-    assert species_allowed_in_country(species, country)
+    print(species_allowed_in_country(species, country))
     
     
-    #%% Test several species
+    #%% Bulk geofence lookups
     
     if True:
         
@@ -2606,86 +2866,3 @@ if False:
         if state is not None:
             state_string = ' ({})'.format(state)
         print('{} ({}) for {}{}: {}'.format(taxonomy_info['common_name'],species,country,state_string,allowed))
-            
-        
-    #%% Test conversion from predictons.json to MD format
-    
-    import os # noqa
-    from megadetector.utils.wi_utils import generate_md_results_from_predictions_json # noqa
-    
-    # detector_source = 'speciesnet'
-    detector_source = 'md'
-    
-    if False:
-        image_folder = r'g:\temp\md-test-images'
-        base_folder = '/home/dmorris/tmp/md-test-images/'
-        if detector_source == 'speciesnet':    
-            predictions_json_file = r"\\wsl$\Ubuntu\home\dmorris\tmp\speciesnet-tests\ensemble-output.json"
-            md_results_file = r"\\wsl$\Ubuntu\home\dmorris\tmp\speciesnet-tests\ensemble-output-md-format.json"
-        else:
-            assert detector_source == 'md'
-            predictions_json_file = r"\\wsl$\Ubuntu\home\dmorris\tmp\speciesnet-tests\ensemble-output-from-md-results.json"
-            md_results_file = r"\\wsl$\Ubuntu\home\dmorris\tmp\speciesnet-tests\ensemble-output-md-format-from-md-results.json"        
-    else:
-        image_folder = r'g:\temp\water-hole'
-        base_folder = '/mnt/g/temp/water-hole/'
-        if detector_source == 'speciesnet':    
-            predictions_json_file = r'g:\temp\water-hole\ensemble-output.json'
-            md_results_file = r'g:\temp\water-hole\ensemble-output.md_format.json'
-        else:
-            assert detector_source == 'md'
-            predictions_json_file = r'g:\temp\water-hole\ensemble-output-md.json'
-            md_results_file = r'g:\temp\water-hole\ensemble-output-md.md_format.json'
-    
-    generate_md_results_from_predictions_json(predictions_json_file=predictions_json_file,
-                                              md_results_file=md_results_file,
-                                              base_folder=base_folder)
-    
-    # from megadetector.utils.path_utils import open_file; open_file(md_results_file)
-    
-    assert os.path.isdir(image_folder)
-    
-   
-    #%% Preview
-    
-    from megadetector.postprocessing.postprocess_batch_results import \
-        PostProcessingOptions, process_batch_results
-    from megadetector.utils import path_utils
-    
-    render_animals_only = False
-    
-    options = PostProcessingOptions()
-    options.image_base_dir = image_folder
-    options.include_almost_detections = True
-    options.num_images_to_sample = None
-    options.confidence_threshold = 0.2
-    options.almost_detection_confidence_threshold = options.confidence_threshold - 0.05
-    options.ground_truth_json_file = None
-    options.separate_detections_by_category = True
-    options.sample_seed = 0
-    options.max_figures_per_html_file = 5000
-    
-    options.parallelize_rendering = True
-    options.parallelize_rendering_n_cores = 10
-    options.parallelize_rendering_with_threads = True
-    options.sort_classification_results_by_count = True
-    
-    if render_animals_only:
-        # Omit some pages from the output, useful when animals are rare
-        options.rendering_bypass_sets = ['detections_person','detections_vehicle',
-                                          'detections_person_vehicle','non_detections']    
-    
-    output_base = r'g:\temp\preview' + '_' + detector_source
-    if render_animals_only:
-        output_base = output_base + '_render_animals_only'
-    os.makedirs(output_base, exist_ok=True)
-    
-    print('Writing preview to {}'.format(output_base))
-    
-    options.md_results_file = md_results_file
-    options.output_dir = output_base
-    ppresults = process_batch_results(options)
-    html_output_file = ppresults.output_html_file
-    
-    path_utils.open_file(html_output_file,attempt_to_open_in_wsl_host=True,browser_name='chrome')
-    # import clipboard; clipboard.copy(html_output_file)