coralnet-toolbox 0.0.70__py2.py3-none-any.whl → 0.0.71__py2.py3-none-any.whl

coralnet_toolbox/Explorer/QtExplorer.py

@@ -130,7 +130,7 @@ class EmbeddingViewer(QWidget):
         # Create a QToolButton to have both a primary action and a dropdown menu
         self.find_mislabels_button = QToolButton()
         self.find_mislabels_button.setText("Find Potential Mislabels")
-        self.find_mislabels_button.setPopupMode(QToolButton.MenuButtonPopup) # Key change for split-button style
+        self.find_mislabels_button.setPopupMode(QToolButton.MenuButtonPopup)  # Key change for split-button style
         self.find_mislabels_button.setToolButtonStyle(Qt.ToolButtonTextOnly)
         self.find_mislabels_button.setStyleSheet(
             "QToolButton::menu-indicator {"
@@ -186,9 +186,18 @@ class EmbeddingViewer(QWidget):
         
         uncertainty_settings_widget.parameters_changed.connect(self.uncertainty_parameters_changed.emit)
         toolbar_layout.addWidget(self.find_uncertain_button)
-
+    
+        # Add a strech and separator
         toolbar_layout.addStretch()
-        
+        toolbar_layout.addWidget(self._create_separator())
+
+        # Center on selection button
+        self.center_on_selection_button = QPushButton()
+        self.center_on_selection_button.setIcon(get_icon("target.png"))
+        self.center_on_selection_button.setToolTip("Center view on selected point(s)")
+        self.center_on_selection_button.clicked.connect(self.center_on_selection)
+        toolbar_layout.addWidget(self.center_on_selection_button)
+                
         # Home button to reset view
         self.home_button = QPushButton()
         self.home_button.setIcon(get_icon("home.png"))
@@ -258,6 +267,7 @@ class EmbeddingViewer(QWidget):
 
         self.find_mislabels_button.setEnabled(points_exist)
         self.find_uncertain_button.setEnabled(points_exist and self.is_uncertainty_analysis_available)
+        self.center_on_selection_button.setEnabled(points_exist and selection_exists)
 
         if self.isolated_mode:
             self.isolate_button.hide()
@@ -270,12 +280,46 @@ class EmbeddingViewer(QWidget):
     def reset_view(self):
         """Reset the view to fit all embedding points."""
         self.fit_view_to_points()
+        
+    def center_on_selection(self):
+        """Centers the view on selected point(s) or maintains the current view if no points are selected."""
+        selected_items = self.graphics_scene.selectedItems()
+        if not selected_items:
+            # No selection, show a message
+            QMessageBox.information(self, "No Selection", "Please select one or more points first.")
+            return
+            
+        # Create a bounding rect that encompasses all selected points
+        selection_rect = None
+        
+        for item in selected_items:
+            if isinstance(item, EmbeddingPointItem):
+                # Get the item's bounding rect in scene coordinates
+                item_rect = item.sceneBoundingRect()
+                
+                # Add padding around the point for better visibility
+                padding = 50  # pixels
+                item_rect = item_rect.adjusted(-padding, -padding, padding, padding)
+                
+                if selection_rect is None:
+                    selection_rect = item_rect
+                else:
+                    selection_rect = selection_rect.united(item_rect)
+        
+        if selection_rect:
+            # Add extra margin for better visibility
+            margin = 20
+            selection_rect = selection_rect.adjusted(-margin, -margin, margin, margin)
+            
+            # Fit the view to the selection rect
+            self.graphics_view.fitInView(selection_rect, Qt.KeepAspectRatio)
 
     def show_placeholder(self):
         """Show the placeholder message and hide the graphics view."""
         self.graphics_view.setVisible(False)
         self.placeholder_label.setVisible(True)
         self.home_button.setEnabled(False)
+        self.center_on_selection_button.setEnabled(False)  # Disable center button
         self.find_mislabels_button.setEnabled(False)
         self.find_uncertain_button.setEnabled(False)
 
@@ -1422,6 +1466,7 @@ class ExplorerWindow(QMainWindow):
 
         self.device = main_window.device
         self.loaded_model = None
+        self.loaded_model_imgsz = 128
 
         self.feature_store = FeatureStore()
         
@@ -1775,13 +1820,15 @@ class ExplorerWindow(QMainWindow):
         """
         Identifies annotations whose label does not match the majority of its
         k-nearest neighbors in the high-dimensional feature space.
+        Skips any annotation or neighbor with an invalid label (id == -1).
         """
         # Get parameters from the stored property instead of hardcoding
         K = self.mislabel_params.get('k', 5)
         agreement_threshold = self.mislabel_params.get('threshold', 0.6)
 
         if not self.embedding_viewer.points_by_id or len(self.embedding_viewer.points_by_id) < K:
-            QMessageBox.information(self, "Not Enough Data",
+            QMessageBox.information(self, 
+                                    "Not Enough Data",
                                     f"This feature requires at least {K} points in the embedding viewer.")
             return
 
@@ -1792,7 +1839,6 @@ class ExplorerWindow(QMainWindow):
         model_info = self.model_settings_widget.get_selected_model()
         model_name, feature_mode = model_info if isinstance(model_info, tuple) else (model_info, "default")
         sanitized_model_name = os.path.basename(model_name).replace(' ', '_')
-        # FIX: Also replace the forward slash to handle "N/A"
         sanitized_feature_mode = feature_mode.replace(' ', '_').replace('/', '_')
         model_key = f"{sanitized_model_name}_{sanitized_feature_mode}"
 
@@ -1802,13 +1848,17 @@ class ExplorerWindow(QMainWindow):
             index = self.feature_store._get_or_load_index(model_key)
             faiss_idx_to_ann_id = self.feature_store.get_faiss_index_to_annotation_id_map(model_key)
             if index is None or not faiss_idx_to_ann_id:
-                QMessageBox.warning(self, "Error", "Could not find a valid feature index for the current model.")
+                QMessageBox.warning(self, 
+                                    "Error", 
+                                    "Could not find a valid feature index for the current model.")
                 return
 
             # Get the high-dimensional features for the points in the current view
             features_dict, _ = self.feature_store.get_features(data_items_in_view, model_key)
             if not features_dict:
-                QMessageBox.warning(self, "Error", "Could not retrieve features for the items in view.")
+                QMessageBox.warning(self, 
+                                    "Error", 
+                                    "Could not retrieve features for the items in view.")
                 return
 
             query_ann_ids = list(features_dict.keys())
@@ -1819,25 +1869,33 @@ class ExplorerWindow(QMainWindow):
 
             mislabeled_ann_ids = []
             for i, ann_id in enumerate(query_ann_ids):
-                current_label = self.data_item_cache[ann_id].effective_label.id
-                
+                data_item = self.data_item_cache[ann_id]
+                # Use preview_label if present, else effective_label
+                label_obj = getattr(data_item, "preview_label", None) or data_item.effective_label
+                current_label_id = getattr(label_obj, "id", "-1")
+                if current_label_id == "-1":
+                    continue  # Skip if label is invalid
+
                 # Get neighbor labels, ignoring the first result (the point itself)
                 neighbor_faiss_indices = I[i][1:]
-                
+
                 neighbor_labels = []
                 for n_idx in neighbor_faiss_indices:
-                    # THIS IS THE CORRECTED LOGIC
                     if n_idx in faiss_idx_to_ann_id:
                         neighbor_ann_id = faiss_idx_to_ann_id[n_idx]
-                        # ADD THIS CHECK to ensure the neighbor hasn't been deleted
                         if neighbor_ann_id in self.data_item_cache:
-                            neighbor_labels.append(self.data_item_cache[neighbor_ann_id].effective_label.id)
+                            neighbor_item = self.data_item_cache[neighbor_ann_id]
+                            neighbor_label_obj = getattr(neighbor_item, "preview_label", None)
+                            if neighbor_label_obj is None:
+                                neighbor_label_obj = neighbor_item.effective_label
+                            neighbor_label_id = getattr(neighbor_label_obj, "id", "-1")
+                            if neighbor_label_id != "-1":
+                                neighbor_labels.append(neighbor_label_id)
 
                 if not neighbor_labels:
                     continue
 
-                # Use the agreement threshold instead of strict majority
-                num_matching_neighbors = neighbor_labels.count(current_label)
+                num_matching_neighbors = neighbor_labels.count(current_label_id)
                 agreement_ratio = num_matching_neighbors / len(neighbor_labels)
 
                 if agreement_ratio < agreement_threshold:
@@ -2082,16 +2140,36 @@ class ExplorerWindow(QMainWindow):
             print(f"Model or mode changed. Reloading {model_name} for '{feature_mode}'.")
             try:
                 model = YOLO(model_name)
+                
+                # Check if the model task is compatible with the selected feature mode
+                if model.task != 'classify' and feature_mode == "Predictions":
+                    QMessageBox.warning(self, 
+                                        "Invalid Mode for Model",
+                                        f"The selected model is a '{model.task}' model. "
+                                        "The 'Predictions' feature mode is only available for 'classify' models. "
+                                        "Reverting to 'Embed Features' mode.")
+
+                    # Force the feature mode combo box back to "Embed Features"
+                    self.model_settings_widget.feature_mode_combo.setCurrentText("Embed Features")
+                    
+                    # On failure, reset the model cache
+                    self.loaded_model = None
+                    self.current_feature_generating_model = None
+                    return None, None
+
                 # Update the cache key to the new successful combination
                 self.current_feature_generating_model = current_run_key
                 self.loaded_model = model
-                imgsz = getattr(model.model.args, 'imgsz', 128)
+                
+                # Get the imgsz, but if it's larger than 128, default to 128
+                imgsz = min(getattr(model.model.args, 'imgsz', 128), 128)
+                self.loaded_model_imgsz = imgsz
                 
                 # Warm up the model
                 dummy_image = np.zeros((imgsz, imgsz, 3), dtype=np.uint8)
                 model.predict(dummy_image, imgsz=imgsz, half=True, device=self.device, verbose=False)
                 
-                return model, imgsz
+                return model, self.loaded_model_imgsz
                 
             except Exception as e:
                 print(f"ERROR: Could not load YOLO model '{model_name}': {e}")
@@ -2100,8 +2178,8 @@ class ExplorerWindow(QMainWindow):
                 self.current_feature_generating_model = None
                 return None, None
         
-        # Model already loaded and cached
-        return self.loaded_model, getattr(self.loaded_model.model.args, 'imgsz', 128)
+        # Model already loaded and cached, return it and its image size
+        return self.loaded_model, self.loaded_model_imgsz
 
     def _prepare_images_from_data_items(self, data_items, progress_bar=None):
         """

coralnet_toolbox/MachineLearning/TrainModel/QtBase.py

@@ -660,6 +660,10 @@ class Base(QDialog):
                 QMessageBox.warning(self, "Import Warning", "The YAML file appears to be empty or invalid.")
                 return
 
+            # For backward compatibility, check if the old nested 'parameters' key exists.
+            # If not, use the whole data dictionary.
+            params_to_load = data.get('parameters', data)
+
             # Helper function to infer type from value
             def infer_type_and_value(value):
                 """
@@ -673,12 +677,9 @@ class Base(QDialog):
                 elif isinstance(value, float):
                     return "float", value
                 elif isinstance(value, str):
-                    # Check for boolean strings
                     if value.lower() in ['true', 'false']:
                         return "bool", value.lower() == 'true'
-                    # Check for numeric strings
                     try:
-                        # Try to convert to int first
                         if '.' not in value:
                             return "int", int(value)
                         else:
@@ -686,14 +687,13 @@ class Base(QDialog):
                     except ValueError:
                         return "string", value
                 else:
-                    # For any other type, convert to string
                     return "string", str(value)
 
             # Clear existing custom parameters before importing
             while self.custom_params:
                 self.remove_parameter_pair()
 
-            # Map parameters to UI controls
+            # Map standard parameters to their UI controls
             param_mapping = {
                 'epochs': self.epochs_spinbox,
                 'patience': self.patience_spinbox,
@@ -712,37 +712,31 @@ class Base(QDialog):
             }
 
             # Update UI controls with imported values
-            for param_name, value in data.items():
+            for param_name, value in params_to_load.items():
                 param_type, converted_value = infer_type_and_value(value)
                 
                 if param_name in param_mapping:
                     widget = param_mapping[param_name]
                     
                     if isinstance(widget, QSpinBox):
-                        if param_type in ['int', 'float'] and isinstance(converted_value, (int, float)):
+                        if isinstance(converted_value, (int, float)):
                             widget.setValue(int(converted_value))
                     elif isinstance(widget, QDoubleSpinBox):
-                        if param_type in ['int', 'float'] and isinstance(converted_value, (int, float)):
+                        if isinstance(converted_value, (int, float)):
                             widget.setValue(float(converted_value))
                     elif isinstance(widget, QComboBox):
                         if param_name in ['multi_scale', 'save', 'weighted', 'val', 'verbose']:
-                            # Boolean parameters
-                            if param_type == 'bool':
-                                widget.setCurrentText("True" if converted_value else "False")
-                        else:
-                            # String parameters like optimizer
-                            if str(converted_value) in [widget.itemText(i) for i in range(widget.count())]:
-                                widget.setCurrentText(str(converted_value))
+                            widget.setCurrentText("True" if converted_value else "False")
+                        elif str(converted_value) in [widget.itemText(i) for i in range(widget.count())]:
+                            widget.setCurrentText(str(converted_value))
                 else:
-                    # Add as custom parameter using inferred type
+                    # Add as a custom parameter
                     self.add_parameter_pair()
-                    param_widgets = self.custom_params[-1]
-                    param_name_widget, param_value_widget, param_type_widget = param_widgets
+                    param_name_widget, param_value_widget, param_type_widget = self.custom_params[-1]
                     
                     param_name_widget.setText(param_name)
                     param_type_widget.setCurrentText(param_type)
                     
-                    # Set value based on type
                     if param_type == "bool":
                         param_value_widget.setText("True" if converted_value else "False")
                     else:
@@ -750,14 +744,14 @@ class Base(QDialog):
 
             QMessageBox.information(self, 
                                     "Import Success", 
-                                    "Parameters successfully imported with automatic type inference")
+                                    "Parameters successfully imported with automatic type inference.")
 
         except Exception as e:
             QMessageBox.critical(self, "Import Error", f"Failed to import parameters: {str(e)}")
 
     def export_parameters(self):
         """
-        Export current parameters to a YAML file with explicit type information.
+        Export current parameters to a flat YAML file.
         """
         file_path, _ = QFileDialog.getSaveFileName(self,
                                                    "Export Parameters to YAML",
@@ -767,69 +761,56 @@ class Base(QDialog):
             return
 
         try:
-            # Structure: types section followed by parameters section
-            export_data = {
-                'types': {},
-                'parameters': {}
-            }
-            
-            # Standard parameters with their types
-            standard_params = {
-                'epochs': ('int', self.epochs_spinbox.value()),
-                'patience': ('int', self.patience_spinbox.value()),
-                'imgsz': ('int', self.imgsz_spinbox.value()),
-                'batch': ('int', self.batch_spinbox.value()),
-                'workers': ('int', self.workers_spinbox.value()),
-                'save_period': ('int', self.save_period_spinbox.value()),
-                'freeze_layers': ('float', self.freeze_layers_spinbox.value()),
-                'dropout': ('float', self.dropout_spinbox.value()),
-                'multi_scale': ('bool', self.multi_scale_combo.currentText() == "True"),
-                'save': ('bool', self.save_combo.currentText() == "True"),
-                'weighted': ('bool', self.weighted_combo.currentText() == "True"),
-                'val': ('bool', self.val_combo.currentText() == "True"),
-                'verbose': ('bool', self.verbose_combo.currentText() == "True"),
-                'optimizer': ('string', self.optimizer_combo.currentText())
-            }
-
-            # Add standard parameters
-            for param_name, (param_type, value) in standard_params.items():
-                export_data['types'][param_name] = param_type
-                export_data['parameters'][param_name] = value
+            # Use a single flat dictionary for export
+            export_data = {}
+
+            # Standard parameters
+            export_data['epochs'] = self.epochs_spinbox.value()
+            export_data['patience'] = self.patience_spinbox.value()
+            export_data['imgsz'] = self.imgsz_spinbox.value()
+            export_data['batch'] = self.batch_spinbox.value()
+            export_data['workers'] = self.workers_spinbox.value()
+            export_data['save_period'] = self.save_period_spinbox.value()
+            export_data['freeze_layers'] = self.freeze_layers_spinbox.value()
+            export_data['dropout'] = self.dropout_spinbox.value()
+            export_data['multi_scale'] = self.multi_scale_combo.currentText() == "True"
+            export_data['save'] = self.save_combo.currentText() == "True"
+            export_data['weighted'] = self.weighted_combo.currentText() == "True"
+            export_data['val'] = self.val_combo.currentText() == "True"
+            export_data['verbose'] = self.verbose_combo.currentText() == "True"
+            export_data['optimizer'] = self.optimizer_combo.currentText()
 
             # Custom parameters
             for param_info in self.custom_params:
-                param_name, param_value, param_type = param_info
-                name = param_name.text().strip()
-                value = param_value.text().strip()
-                type_name = param_type.currentText()
+                param_name_widget, param_value_widget, param_type_widget = param_info
+                name = param_name_widget.text().strip()
+                value_str = param_value_widget.text().strip()
+                type_name = param_type_widget.currentText()
                 
-                if name and value:
-                    export_data['types'][name] = type_name
-                    
-                    if type_name == "bool":
-                        export_data['parameters'][name] = value.lower() == "true"
-                    elif type_name == "int":
-                        try:
-                            export_data['parameters'][name] = int(value)
-                        except ValueError:
-                            export_data['parameters'][name] = value
-                            export_data['types'][name] = "string"  # Fallback to string
-                    elif type_name == "float":
-                        try:
-                            export_data['parameters'][name] = float(value)
-                        except ValueError:
-                            export_data['parameters'][name] = value
-                            export_data['types'][name] = "string"  # Fallback to string
-                    else:  # string type
-                        export_data['parameters'][name] = value
-
-            # Write to YAML file
+                if name and value_str:
+                    # Convert value to the correct type before exporting
+                    try:
+                        if type_name == "bool":
+                            value = value_str.lower() == "true"
+                        elif type_name == "int":
+                            value = int(value_str)
+                        elif type_name == "float":
+                            value = float(value_str)
+                        else:  # string type
+                            value = value_str
+                        export_data[name] = value
+                    except ValueError:
+                        # If conversion fails, save it as a string
+                        print(f"Warning: Could not convert '{value_str}' to {type_name} for parameter '{name}'. Saving as string.")
+                        export_data[name] = value_str
+
+            # Write the flat dictionary to the YAML file
             with open(file_path, 'w') as f:
-                yaml.dump(export_data, f, default_flow_style=False, indent=2)
+                yaml.dump(export_data, f, default_flow_style=False, sort_keys=False, indent=2)
 
             QMessageBox.information(self, 
                                     "Export Success", 
-                                    "Parameters successfully exported")
+                                    "Parameters successfully exported.")
 
         except Exception as e:
             QMessageBox.critical(self, 

coralnet_toolbox/__init__.py

@@ -1,6 +1,6 @@
 """Top-level package for CoralNet-Toolbox."""
 
-__version__ = "0.0.70"
+__version__ = "0.0.71"
 __author__ = "Jordan Pierce"
 __email__ = "jordan.pierce@noaa.gov"
 __credits__ = "National Center for Coastal and Ocean Sciences (NCCOS)"

{coralnet_toolbox-0.0.70.dist-info → coralnet_toolbox-0.0.71.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coralnet-toolbox
-Version: 0.0.70
+Version: 0.0.71
 Summary: Tools for annotating and developing ML models for benthic imagery
 Author-email: Jordan Pierce <jordan.pierce@noaa.gov>
 License: MIT License
@@ -179,7 +179,7 @@ Enhance your CoralNet experience with these tools:
 - 🚀 Optimize: Productionize models for faster inferencing
 - ⚙️ Batch Inference: Perform predictions on multiple images, automatically
 - 🎞️ Video Inference: Perform predictions on a video in real-time, record the output and analytics
-- 🔮 Explorer: Cluster, view, and re-label annotations using embeddings, mapped from feature-space
+- 🔮 [Explorer](https://youtu.be/68eZt5l_7nA): Cluster, view, and re-label annotations using embeddings, mapped from feature-space
 - ↔️ I/O: Import and Export annotations from / to CoralNet, Viscore, and TagLab
   - Export annotations as [GeoJSONs](https://datatracker.ietf.org/doc/html/rfc7946), segmentation masks
 - 📸 YOLO: Import and Export YOLO datasets for machine learning

{coralnet_toolbox-0.0.70.dist-info → coralnet_toolbox-0.0.71.dist-info}/RECORD

@@ -7,7 +7,7 @@ coralnet_toolbox/QtMainWindow.py,sha256=W86kc-ZFmZHcSKcNTWN5RFCvt7sysvTCYZrPWZPW
 coralnet_toolbox/QtPatchSampling.py,sha256=Ehj06auBGfQwIruLNYQjF8eFOCpl8G72p42UXXb2mUo,29013
 coralnet_toolbox/QtProgressBar.py,sha256=pnozUOcVjfO_yTS9z8wOMPcrrrOtG_FeCknTcdI6eyk,6250
 coralnet_toolbox/QtWorkArea.py,sha256=YXRvHQKpWUtWyv_o9lZ8rmxfm28dUOG9pmMUeimDhQ4,13578
-coralnet_toolbox/__init__.py,sha256=jJh2Y95YrQKB66vTaSKx69MySCS7FLjHdOkQcpz04A4,207
+coralnet_toolbox/__init__.py,sha256=K-BGYPTYU1ySXgZWS4vmpHfRksFJb3SAyX73veK1hdE,207
 coralnet_toolbox/main.py,sha256=6j2B_1reC_KDmqvq1C0fB-UeSEm8eeJOozp2f4XXMLQ,1573
 coralnet_toolbox/utilities.py,sha256=eUkxXuWaNFH83LSW-KniwujkXKJ2rK04czx3k3OPiAY,27115
 coralnet_toolbox/Annotations/QtAnnotation.py,sha256=-3ASbjl1dXw9U731vyCgwyiyZT9zOD5Mvp1jt-7bCnA,29242
@@ -36,7 +36,7 @@ coralnet_toolbox/CoralNet/QtAuthenticate.py,sha256=Y__iY0Kcosz6AOV7dlJBwiB6Hte40
 coralnet_toolbox/CoralNet/QtDownload.py,sha256=HBb8TpZRIEFirGIaIAV1v8qg3fL4cP6Bf-hUiqXoiLE,48516
 coralnet_toolbox/CoralNet/__init__.py,sha256=ILkAZh6mlAK1UaCCZjCB9JZxd-oY4cIgfnIC8UgjjIU,188
 coralnet_toolbox/Explorer/QtDataItem.py,sha256=-O2Tneh9wYbAZarqwb_Cvy5cP1F_zQH2IAw9c-rHy1Y,13572
-coralnet_toolbox/Explorer/QtExplorer.py,sha256=iKtp3m7PowAZCOmJSx-Z34M50kmVCUNHrbCBQIBd12k,118900
+coralnet_toolbox/Explorer/QtExplorer.py,sha256=IATLlZi57m5XU1KIG-oGNGqhcZEpjxQeilmKGrKMIFo,122968
 coralnet_toolbox/Explorer/QtFeatureStore.py,sha256=kMn--vuBed6wZS-BQhHt_KBA5z-tL1ydFgFkkIoGiB4,6742
 coralnet_toolbox/Explorer/QtSettingsWidgets.py,sha256=hIMj2lzqGKBoFWKYolH7bEPm5ePAIzYcGjYRQv2uWFE,27656
 coralnet_toolbox/Explorer/__init__.py,sha256=wZPhf2oaUUyIQ2WK48Aj-4q1ENIZG2dGl1HF_mjhI6w,116
@@ -89,6 +89,7 @@ coralnet_toolbox/Icons/rocket.png,sha256=iMlRGlrNBS_dNBD2XIpN4RSrphCGbw_Ds1AYJ01
 coralnet_toolbox/Icons/select.png,sha256=twnMIO9ylQYjvyGnAR28V6K3ds6xpArZQTrvf0uxS6g,1896
 coralnet_toolbox/Icons/settings.png,sha256=rklROt3oKrfEk_qwN9J-JwvKok08iOkZy3OD4oNsLJQ,1376
 coralnet_toolbox/Icons/snake.png,sha256=cwcekSkXwDi_fhtTU48u7FN4bIybbY53cWK0n7-IN9A,2361
+coralnet_toolbox/Icons/target.png,sha256=jzb-S_sXWT8MfbvefhDNsuTdAZgV2nGf1ieawaCkByM,1702
 coralnet_toolbox/Icons/tile.png,sha256=WiXKBpWVBfPv7gC8dnkc_gW3wuLQmLUyxYMWEM-G9ZU,382
 coralnet_toolbox/Icons/transparent.png,sha256=ZkuGkVzh6zLVNau1Wj166-TtUlbCRqJObGt4vxMxnLk,1098
 coralnet_toolbox/Icons/turtle.png,sha256=55OG5atmEs8nIUiN2B5hW-Jx1fpuY9QI-zolQoUOKWw,1971
@@ -147,7 +148,7 @@ coralnet_toolbox/MachineLearning/MergeDatasets/QtClassify.py,sha256=FI4WdxJ4-vtn
 coralnet_toolbox/MachineLearning/MergeDatasets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 coralnet_toolbox/MachineLearning/OptimizeModel/QtBase.py,sha256=06irheL8aKvtwKBQLLJUohvWvrMqKFC-jhEEoVqIYdg,8890
 coralnet_toolbox/MachineLearning/OptimizeModel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-coralnet_toolbox/MachineLearning/TrainModel/QtBase.py,sha256=lLGmgDSvjQFYD2RdF7eC6U5xU5in2rC26RQ3lmKvfLY,37460
+coralnet_toolbox/MachineLearning/TrainModel/QtBase.py,sha256=f__pgcG8yyV4IQbICED4q4YWO6GnNtD5b5UGpWuv4c0,36580
 coralnet_toolbox/MachineLearning/TrainModel/QtClassify.py,sha256=ss5ppGbrpULzUPmeRmfqZjiqZPp7XbdUZ4BzSX0ehu0,3267
 coralnet_toolbox/MachineLearning/TrainModel/QtDetect.py,sha256=uxopZkrNkl3tImMNSDwC2ENpFAxdG0NLiwRwqNnbep0,4467
 coralnet_toolbox/MachineLearning/TrainModel/QtSegment.py,sha256=y8bpNS24SQxyg967RSi6TraqHSmlJYj8kbvC_5HMBIM,3597
@@ -215,9 +216,9 @@ coralnet_toolbox/Tools/QtTool.py,sha256=2MCjT151gYBN8KbsK0GX4WOrEg1uw3oeSkp7Elw1
 coralnet_toolbox/Tools/QtWorkAreaTool.py,sha256=-CDrEPenOdSI3sf5wn19Cip4alE1ef7WsRDxQFDkHlc,22162
 coralnet_toolbox/Tools/QtZoomTool.py,sha256=F9CAoABv1jxcUS7dyIh1FYjgjOXYRI1xtBPNIR1g62o,4041
 coralnet_toolbox/Tools/__init__.py,sha256=218iQ8IFXIkKXiUDVYtXk9e08UY9-LhHjcryaJAanQ0,797
-coralnet_toolbox-0.0.70.dist-info/licenses/LICENSE.txt,sha256=AURacZ_G_PZKqqPQ9VB9Sqegblk67RNgWSGAYKwXXMY,521
-coralnet_toolbox-0.0.70.dist-info/METADATA,sha256=2BX8ksbRkMXuBR4m5xY6ks_qfTqmCZjEPwkpwCDccW0,18120
-coralnet_toolbox-0.0.70.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-coralnet_toolbox-0.0.70.dist-info/entry_points.txt,sha256=oEeMoDlJ_2lq95quOeDHIx9hZpubUlSo80OLtgbcrbM,63
-coralnet_toolbox-0.0.70.dist-info/top_level.txt,sha256=SMWPh4_9JfB8zVpPOOvjucV2_B_hvWW7bNWmMjG0LsY,17
-coralnet_toolbox-0.0.70.dist-info/RECORD,,
+coralnet_toolbox-0.0.71.dist-info/licenses/LICENSE.txt,sha256=AURacZ_G_PZKqqPQ9VB9Sqegblk67RNgWSGAYKwXXMY,521
+coralnet_toolbox-0.0.71.dist-info/METADATA,sha256=LltT45S41MrUplIQGHLJ_1rjuFT8PccNnbRCUw2ODRQ,18152
+coralnet_toolbox-0.0.71.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+coralnet_toolbox-0.0.71.dist-info/entry_points.txt,sha256=oEeMoDlJ_2lq95quOeDHIx9hZpubUlSo80OLtgbcrbM,63
+coralnet_toolbox-0.0.71.dist-info/top_level.txt,sha256=SMWPh4_9JfB8zVpPOOvjucV2_B_hvWW7bNWmMjG0LsY,17
+coralnet_toolbox-0.0.71.dist-info/RECORD,,