coralnet-toolbox 0.0.74__py2.py3-none-any.whl → 0.0.76__py2.py3-none-any.whl

coralnet_toolbox/MachineLearning/VideoInference/YOLO3D/run.py

@@ -189,6 +189,21 @@ Examples:
         help='Filter by specific class IDs (e.g., --classes 0 1 2 for persons, bicycles, cars)'
     )
     
+    # Frame range parameters
+    parser.add_argument(
+        '--start_at',
+        type=int,
+        default=0,
+        help='Start processing at this frame number (0-based)'
+    )
+    parser.add_argument(
+        '--end_at',
+        type=int,
+        default=None,
+        help='End processing at this frame number (inclusive, 0-based). If not provided, '
+             'process until the end of the video.'
+    )
+    
     # Device settings
     parser.add_argument(
         '--device',
@@ -222,6 +237,8 @@ Examples:
         action='store_true',
         help='Show all visualization windows (result, depth, detection). By default, only the result frame is shown.'
     )
+    
+    
     return parser.parse_args()
 
 
@@ -271,19 +288,25 @@ def main():
     enable_bev = not args.no_bev
     enable_display = not args.no_display
     show_all_frames = args.yes_display
+    
+    # Frame range parameters
+    start_frame = args.start_at
+    end_frame = args.end_at
+    
     # Camera parameters - simplified approach
     camera_params_file = None  # Path to camera parameters file (None to use default parameters)
     # ===============================================
-    print(f"\nConfiguration:")
+    print("\nConfiguration:")
     print(f"Input source: {source}")
     print(f"Output path: {output_path}")
     if target_size is not None:
         print(f"Target size: {target_size}px (longest edge)")
     else:
-        print(f"Using original resolution (no scaling)")
+        print("Using original resolution (no scaling)")
     print(f"YOLO model: {'Custom path: ' + yolo_model_path if yolo_model_path else 'Size: ' + yolo_model_size}")
     print(f"Depth model size: {depth_model_size}")
     print(f"Device: {device}")
+    print(f"Frame range: {start_frame} to {end_frame if end_frame is not None else 'end'}")
     print(f"Tracking: {'enabled' if enable_tracking else 'disabled'}")
     print(f"Bird's Eye View: {'enabled' if enable_bev else 'disabled'}")
     print(f"Display: {'enabled' if enable_display else 'disabled'}")
@@ -382,9 +405,52 @@ def main():
         # Use a scale that works well for the 1-5 meter range
         bev = BirdEyeView(image_shape=(width, height), scale=100)  # Increased scale to spread objects out
     
-    # Initialize video writer
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    # Initialize video writer - use a more reliable codec and check output path
+    output_dir = os.path.dirname(output_path)
+    if output_dir and not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # On Windows, try different codec options
+    if sys.platform == 'win32':
+        try:
+            # First try H264 codec
+            fourcc = cv2.VideoWriter_fourcc(*'H264')
+            out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+            
+            # Check if writer was successfully initialized
+            if not out.isOpened():
+                # Fallback to XVID codec
+                fourcc = cv2.VideoWriter_fourcc(*'XVID')
+                out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+                
+                if not out.isOpened():
+                    # Last resort, try MJPG
+                    fourcc = cv2.VideoWriter_fourcc(*'MJPG')
+                    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+                    
+                    if not out.isOpened():
+                        print(f"Warning: Could not create output video with standard codecs. Trying AVI format.")
+                        # Try changing extension to .avi
+                        output_path = os.path.splitext(output_path)[0] + '.avi'
+                        fourcc = cv2.VideoWriter_fourcc(*'XVID')
+                        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        except Exception as e:
+            print(f"Error initializing video writer: {e}")
+            # Last fallback to MP4V
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    else:
+        # For other platforms, use mp4v codec
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+
+    # Check if writer was successfully initialized
+    if not out.isOpened():
+        print(f"Error: Could not create output video file at {output_path}")
+        print("Continuing without saving output video.")
+        out = None
+    else:
+        print(f"Successfully opened output video file: {output_path}")
     
     # Initialize variables for FPS calculation
     frame_count = 0
@@ -394,6 +460,7 @@ def main():
     print("Starting processing...")
     
     # Main loop
+    current_frame = 0
     while True:
         # Check for key press at the beginning of each loop
         if enable_display:
@@ -401,11 +468,22 @@ def main():
             if key == ord('q') or key == 27 or (key & 0xFF) == ord('q') or (key & 0xFF) == 27:
                 print("Exiting program...")
                 break
-        try:            # Read frame
+        try:            
+            # Read frame
             ret, frame = cap.read()
             if not ret:
                 break
             
+            # Skip frames before start_frame
+            if current_frame < start_frame:
+                current_frame += 1
+                continue
+                
+            # Stop if we've processed the end_frame
+            if end_frame is not None and current_frame > end_frame:
+                print(f"Reached end frame {end_frame}, stopping processing.")
+                break
+                
             # Apply resizing if needed
             if target_size is not None:
                 frame = cv2.resize(frame, (width, height))
@@ -543,7 +621,7 @@ def main():
                 fps_display = f"FPS: {fps_value:.1f}"
 
             # Add FPS and device info to the result frame (top-right corner)
-            text = f"{fps_display} | Device: {device}"
+            text = f"{fps_display} | Device: {device} | Frame: {current_frame}"
 
             # Calculate text size for right alignment
             (text_width, text_height), _ = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2)
@@ -584,8 +662,9 @@ def main():
             except Exception as e:
                 print(f"Error adding depth map to result: {e}")
             
-            # Write frame to output video
-            out.write(result_frame)
+            # Write frame to output video (only if writer is valid)
+            if out is not None and out.isOpened():
+                out.write(result_frame)
             
             # Display frames only if display is enabled
             if enable_display:
@@ -594,12 +673,15 @@ def main():
                     cv2.imshow("Depth Map", depth_colored)
                     cv2.imshow("Object Detection", detection_frame)
                     
-                # Check for key press again at the end of the loop
-                key = cv2.waitKey(1)
-                if key == ord('q') or key == 27 or (key & 0xFF) == ord('q') or (key & 0xFF) == 27:
-                    print("Exiting program...")
-                    break
-        
+            # Check for key press again at the end of the loop
+            key = cv2.waitKey(1)
+            if key == ord('q') or key == 27 or (key & 0xFF) == ord('q') or (key & 0xFF) == 27:
+                print("Exiting program...")
+                break
+                
+            # Increment frame counter
+            current_frame += 1
+            
         except Exception as e:
             print(f"Error processing frame: {e}")
             # Also check for key press during exception handling
@@ -608,12 +690,16 @@ def main():
                 if key == ord('q') or key == 27 or (key & 0xFF) == ord('q') or (key & 0xFF) == 27:
                     print("Exiting program...")
                     break
+            
+            # Still increment frame counter even if there was an error
+            current_frame += 1
             continue
     
     # Clean up
     print("Cleaning up resources...")
     cap.release()
-    out.release()
+    if out is not None:
+        out.release()
     cv2.destroyAllWindows()
     
     print(f"Processing complete. Output saved to {output_path}")

coralnet_toolbox/QtAnnotationWindow.py

@@ -492,9 +492,6 @@ class AnnotationWindow(QGraphicsView):
             relative_area = 1.0  # fallback, treat as full image
 
         # Step 3: Map ratio to padding factor (smaller annotation = more padding)
-        # Example: padding_factor = clamp(0.5 * (1/relative_area)**0.5, 0.1, 0.5)
-        # - For very small annotations, padding approaches 0.5 (50%)
-        # - For large annotations, padding approaches 0.1 (10%)
         import math
         min_padding = 0.1  # 10%
         max_padding = 0.5  # 50%
@@ -503,23 +500,32 @@ class AnnotationWindow(QGraphicsView):
         else:
             padding_factor = min_padding
 
-        # Step 4: Apply dynamic padding
-        padding_x = annotation_rect.width() * padding_factor
-        padding_y = annotation_rect.height() * padding_factor
+        # Step 4: Apply dynamic padding with minimum values to prevent zero width/height
+        min_padding_absolute = 1.0  # Minimum padding in pixels
+        padding_x = max(annotation_rect.width() * padding_factor, min_padding_absolute)
+        padding_y = max(annotation_rect.height() * padding_factor, min_padding_absolute)
         padded_rect = annotation_rect.adjusted(-padding_x, -padding_y, padding_x, padding_y)
 
         # Fit the padded annotation rect in the view
         self.fitInView(padded_rect, Qt.KeepAspectRatio)
 
-        # Update the zoom factor based on the new view transformation
+        # Update the zoom factor based on the new view transformation with safety checks
         view_rect = self.viewport().rect()
-        zoom_x = view_rect.width() / padded_rect.width()
-        zoom_y = view_rect.height() / padded_rect.height()
+        if padded_rect.width() > 0:
+            zoom_x = view_rect.width() / padded_rect.width()
+        else:
+            zoom_x = 1.0  # Default zoom if width is zero
+        
+        if padded_rect.height() > 0:
+            zoom_y = view_rect.height() / padded_rect.height()
+        else:
+            zoom_y = 1.0  # Default zoom if height is zero
+            
         self.zoom_factor = min(zoom_x, zoom_y)
 
         # Signal that the view has changed
         self.viewChanged.emit(*self.get_image_dimensions())
-
+    
     def cycle_annotations(self, direction):
         """Cycle through annotations in the specified direction."""
         # Get the annotations for the current image

coralnet_toolbox/QtEventFilter.py

@@ -24,7 +24,7 @@ class GlobalEventFilter(QObject):
         self.segment_deploy_model_dialog = main_window.segment_deploy_model_dialog
         self.sam_deploy_generator_dialog = main_window.sam_deploy_generator_dialog
         self.see_anything_deploy_generator_dialog = main_window.see_anything_deploy_generator_dialog
-        self.auto_distill_deploy_model_dialog = main_window.auto_distill_deploy_model_dialog
+        self.transformers_deploy_model_dialog = main_window.transformers_deploy_model_dialog
         
     def eventFilter(self, obj, event):
         # Check for explorer window first - this applies to all event types
@@ -75,10 +75,10 @@ class GlobalEventFilter(QObject):
                 if event.key() == Qt.Key_5:
                     self.see_anything_deploy_generator_dialog.predict()
                     return True
-                
-                # Handle hotkey for auto distill prediction
+
+                # Handle hotkey for transformers prediction
                 if event.key() == Qt.Key_6:
-                    self.auto_distill_deploy_model_dialog.predict()
+                    self.transformers_deploy_model_dialog.predict()
                     return True
 
                 # Handle annotation cycling hotkeys

coralnet_toolbox/QtImageWindow.py

@@ -578,13 +578,9 @@ class ImageWindow(QWidget):
                 
             # Immediately update filtered paths to include the new image
             # This ensures the image will be visible in the table right away
-            if self.table_model.filtered_paths == self.raster_manager.image_paths[:-1]:
-                # No filters are active, so just add the new path
-                self.table_model.filtered_paths.append(image_path)
-                self.table_model.dataChanged.emit(
-                    self.table_model.index(0, 0),
-                    self.table_model.index(len(self.table_model.filtered_paths) - 1, 
-                                           self.table_model.columnCount() - 1))
+            if len(self.table_model.filtered_paths) == len(self.raster_manager.image_paths) - 1:
+                # No filters are active, so efficiently add the new path to the model
+                self.table_model.add_path(image_path)
             else:
                 # Filters are active, so run filtering again
                 self.filter_images()

coralnet_toolbox/QtMainWindow.py

@@ -9,6 +9,9 @@ import requests
 
 from packaging import version
 
+import torch
+
+from PyQt5 import sip
 from PyQt5.QtGui import QIcon, QMouseEvent
 from PyQt5.QtCore import Qt, pyqtSignal, QEvent, QSize, QPoint
 from PyQt5.QtWidgets import (QListWidget, QCheckBox, QFrame, QComboBox)
@@ -18,6 +21,7 @@ from PyQt5.QtWidgets import (QMainWindow, QApplication, QToolBar, QAction, QSize
                              QGroupBox)
 
 from coralnet_toolbox.QtEventFilter import GlobalEventFilter
+
 from coralnet_toolbox.QtAnnotationWindow import AnnotationWindow
 from coralnet_toolbox.QtConfidenceWindow import ConfidenceWindow
 from coralnet_toolbox.QtImageWindow import ImageWindow
@@ -99,9 +103,9 @@ from coralnet_toolbox.SeeAnything import (
     BatchInferenceDialog as SeeAnythingBatchInferenceDialog
 )
 
-from coralnet_toolbox.AutoDistill import (
-    DeployModelDialog as AutoDistillDeployModelDialog,
-    BatchInferenceDialog as AutoDistillBatchInferenceDialog
+from coralnet_toolbox.Transformers import (
+    DeployModelDialog as TransformersDeployModelDialog,
+    BatchInferenceDialog as TransformersBatchInferenceDialog
 )
 
 from coralnet_toolbox.CoralNet import (
@@ -114,9 +118,9 @@ from coralnet_toolbox.BreakTime import (
     BreakoutGame
 )
 
-from coralnet_toolbox.Icons import get_icon
+from coralnet_toolbox.QtSystemMonitor import SystemMonitor
 
-from coralnet_toolbox.utilities import get_available_device
+from coralnet_toolbox.Icons import get_icon
 
 
 # ----------------------------------------------------------------------------------------------------------------------
@@ -155,6 +159,7 @@ class MainWindow(QMainWindow):
         self.opaque_icon = get_icon("opaque.png")
         self.all_icon = get_icon("all.png")
         self.parameters_icon = get_icon("parameters.png")
+        self.system_monitor_icon = get_icon("system_monitor.png")
         self.add_icon = get_icon("add.png")
         self.remove_icon = get_icon("remove.png")
         self.edit_icon = get_icon("edit.png")
@@ -193,6 +198,8 @@ class MainWindow(QMainWindow):
         self.label_window = LabelWindow(self)
         self.confidence_window = ConfidenceWindow(self)
         
+        self.system_monitor = None
+        
         self.explorer_window = None  # Initialized in open_explorer_window
 
         # TODO update IO classes to have dialogs
@@ -262,9 +269,9 @@ class MainWindow(QMainWindow):
         self.see_anything_deploy_generator_dialog = SeeAnythingDeployGeneratorDialog(self)
         self.see_anything_batch_inference_dialog = SeeAnythingBatchInferenceDialog(self)
 
-        # Create dialogs (AutoDistill)
-        self.auto_distill_deploy_model_dialog = AutoDistillDeployModelDialog(self)
-        self.auto_distill_batch_inference_dialog = AutoDistillBatchInferenceDialog(self)
+        # Create dialogs (Transformers)
+        self.transformers_deploy_model_dialog = TransformersDeployModelDialog(self)
+        self.transformers_batch_inference_dialog = TransformersBatchInferenceDialog(self)
 
         # Create dialogs (Tile)
         self.classify_tile_dataset_dialog = ClassifyTileDatasetDialog(self)
@@ -601,6 +608,17 @@ class MainWindow(QMainWindow):
         self.ml_segment_video_inference_action = QAction("Segment", self)
         self.ml_segment_video_inference_action.triggered.connect(self.open_segment_video_inference_dialog)
         self.ml_video_inference_menu.addAction(self.ml_segment_video_inference_action) 
+        
+        # Transformers menu
+        self.transformers_menu = self.menu_bar.addMenu("Transformers")
+        # Deploy Model
+        self.transformers_deploy_model_action = QAction("Deploy Model", self)
+        self.transformers_deploy_model_action.triggered.connect(self.open_transformers_deploy_model_dialog)
+        self.transformers_menu.addAction(self.transformers_deploy_model_action)
+        # Batch Inference
+        self.transformers_batch_inference_action = QAction("Batch Inference", self)
+        self.transformers_batch_inference_action.triggered.connect(self.open_transformers_batch_inference_dialog)
+        self.transformers_menu.addAction(self.transformers_batch_inference_action)
 
         # SAM menu
         self.sam_menu = self.menu_bar.addMenu("SAM")
@@ -640,17 +658,6 @@ class MainWindow(QMainWindow):
         self.see_anything_batch_inference_action.triggered.connect(self.open_see_anything_batch_inference_dialog)
         self.see_anything_menu.addAction(self.see_anything_batch_inference_action)
 
-        # Auto Distill menu
-        self.auto_distill_menu = self.menu_bar.addMenu("AutoDistill")
-        # Deploy Model
-        self.auto_distill_deploy_model_action = QAction("Deploy Model", self)
-        self.auto_distill_deploy_model_action.triggered.connect(self.open_auto_distill_deploy_model_dialog)
-        self.auto_distill_menu.addAction(self.auto_distill_deploy_model_action)
-        # Batch Inference
-        self.auto_distill_batch_inference_action = QAction("Batch Inference", self)
-        self.auto_distill_batch_inference_action.triggered.connect(self.open_auto_distill_batch_inference_dialog)
-        self.auto_distill_menu.addAction(self.auto_distill_batch_inference_action)
-
         # Help menu
         self.help_menu = self.menu_bar.addMenu("Help")
 
@@ -659,9 +666,13 @@ class MainWindow(QMainWindow):
         self.check_for_updates_action.triggered.connect(self.open_check_for_updates_dialog)
         self.help_menu.addAction(self.check_for_updates_action)
         # Usage
-        self.usage_action = QAction("Usage", self)
+        self.usage_action = QAction("Usage / Hotkeys", self)
         self.usage_action.triggered.connect(self.open_usage_dialog)
         self.help_menu.addAction(self.usage_action)
+        # System Monitor
+        self.system_monitor_action = QAction("System Monitor", self)
+        self.system_monitor_action.triggered.connect(self.open_system_monitor_dialog)
+        self.help_menu.addAction(self.system_monitor_action)
         # Issues / Feature Requests
         self.create_issue_action = QAction("Issues / Feature Requests", self)
         self.create_issue_action.triggered.connect(self.open_create_new_issue_dialog)
@@ -828,15 +839,15 @@ class MainWindow(QMainWindow):
         self.toolbar.addWidget(spacer)
 
         # Add the device label widget as an action in the toolbar
-        self.devices = get_available_device()
-        self.current_device_index = 0
-        self.device = self.devices[self.current_device_index]
+        self.devices = self.get_available_devices()
+        # Get the 'best' device available
+        self.device = self.devices[-1]
 
         if self.device.startswith('cuda'):
-            if len(self.devices) == 1:
-                device_icon = self.rabbit_icon
-            else:
+            if len([d for d in self.devices if d.endswith('cuda')]) > 1:
                 device_icon = self.rocket_icon
+            else:
+                device_icon = self.rabbit_icon
             device_tooltip = self.device
         elif self.device == 'mps':
             device_icon = self.apple_icon
@@ -1028,9 +1039,9 @@ class MainWindow(QMainWindow):
         self.left_layout.addWidget(self.annotation_window, 85)
         self.left_layout.addWidget(self.label_window, 15)
 
-        # Add widgets to right layout
-        self.right_layout.addWidget(self.image_window, 54)
-        self.right_layout.addWidget(self.confidence_window, 46)
+        # Adjust the right layout with new proportions
+        self.right_layout.addWidget(self.image_window, 54)  # 54% for image window
+        self.right_layout.addWidget(self.confidence_window, 46)  # 46% for confidence window
 
         # Add left and right layouts to main layout
         self.main_layout.addLayout(self.left_layout, 85)
@@ -1054,12 +1065,17 @@ class MainWindow(QMainWindow):
         self.showMaximized()
 
     def closeEvent(self, event):
-        """Ensure the explorer window is closed when the main window closes."""
+        """Ensure the explorer window and system monitor are closed when the main window closes."""
         if self.explorer_window:
             # Setting parent to None prevents it from being deleted with main window
             # before it can be properly handled.
             self.explorer_window.setParent(None)
             self.explorer_window.close()
+        
+        # Close the system monitor if it exists
+        if self.system_monitor:
+            self.system_monitor.close()
+            
         super().closeEvent(event)
 
     def changeEvent(self, event):
@@ -1374,6 +1390,20 @@ class MainWindow(QMainWindow):
             self.sam_tool_action.setChecked(False)
             self.see_anything_tool_action.setChecked(False)
             self.work_area_tool_action.setChecked(False)
+    
+    def get_available_devices(self):
+        """
+        Get available devices
+
+        :return:
+        """
+        devices = ['cpu',]
+        if torch.backends.mps.is_available():
+            devices.append('mps')
+        if torch.cuda.is_available():
+            for i in range(torch.cuda.device_count()):
+                devices.append(f'cuda:{i}')
+        return devices
 
     def toggle_device(self):
         dialog = DeviceSelectionDialog(self.devices, self)
@@ -2211,6 +2241,40 @@ class MainWindow(QMainWindow):
             self.segment_video_inference_dialog.exec_()
         except Exception as e:
             QMessageBox.critical(self, "Critical Error", f"{e}")
+            
+    def open_transformers_deploy_model_dialog(self):
+        """Open the Transformers Deploy Model dialog to deploy an Transformers model."""
+        if not self.image_window.raster_manager.image_paths:
+            QMessageBox.warning(self,
+                                "Transformers Deploy Model",
+                                "No images are present in the project.")
+            return
+
+        try:
+            self.untoggle_all_tools()
+            self.transformers_deploy_model_dialog.exec_()
+        except Exception as e:
+            QMessageBox.critical(self, "Critical Error", f"{e}")
+
+    def open_transformers_batch_inference_dialog(self):
+        """Open the Transformers Batch Inference dialog to run batch inference with Transformers."""
+        if not self.image_window.raster_manager.image_paths:
+            QMessageBox.warning(self,
+                                "Transformers Batch Inference",
+                                "No images are present in the project.")
+            return
+
+        if not self.transformers_deploy_model_dialog.loaded_model:
+            QMessageBox.warning(self,
+                                "Transformers Batch Inference",
+                                "Please deploy a model before running batch inference.")
+            return
+
+        try:
+            self.untoggle_all_tools()
+            self.transformers_batch_inference_dialog.exec_()
+        except Exception as e:
+            QMessageBox.critical(self, "Critical Error", f"{e}")
 
     def open_sam_deploy_predictor_dialog(self):
         """Open the SAM Deploy Predictor dialog to deploy a SAM predictor."""
@@ -2328,40 +2392,16 @@ class MainWindow(QMainWindow):
             self.see_anything_batch_inference_dialog.exec_()
         except Exception as e:
             QMessageBox.critical(self, "Critical Error", f"{e}")
-
-    def open_auto_distill_deploy_model_dialog(self):
-        """Open the AutoDistill Deploy Model dialog to deploy an AutoDistill model."""
-        if not self.image_window.raster_manager.image_paths:
-            QMessageBox.warning(self,
-                                "AutoDistill Deploy Model",
-                                "No images are present in the project.")
-            return
-
-        try:
-            self.untoggle_all_tools()
-            self.auto_distill_deploy_model_dialog.exec_()
-        except Exception as e:
-            QMessageBox.critical(self, "Critical Error", f"{e}")
-
-    def open_auto_distill_batch_inference_dialog(self):
-        """Open the AutoDistill Batch Inference dialog to run batch inference with AutoDistill."""
-        if not self.image_window.raster_manager.image_paths:
-            QMessageBox.warning(self,
-                                "AutoDistill Batch Inference",
-                                "No images are present in the project.")
-            return
-
-        if not self.auto_distill_deploy_model_dialog.loaded_model:
-            QMessageBox.warning(self,
-                                "AutoDistill Batch Inference",
-                                "Please deploy a model before running batch inference.")
-            return
-
-        try:
-            self.untoggle_all_tools()
-            self.auto_distill_batch_inference_dialog.exec_()
-        except Exception as e:
-            QMessageBox.critical(self, "Critical Error", f"{e}")
+            
+    def open_system_monitor_dialog(self):
+        """Open the system system monitor window."""
+        if self.system_monitor is None or sip.isdeleted(self.system_monitor):
+            self.system_monitor = SystemMonitor()
+        
+        # Show the monitor window
+        self.system_monitor.show()
+        self.system_monitor.activateWindow()
+        self.system_monitor.raise_()
             
     def open_usage_dialog(self):
         """Display QMessageBox with link to create new issue on GitHub."""

coralnet_toolbox/QtProgressBar.py

@@ -39,6 +39,7 @@ class ProgressBar(QDialog):
 
         # Create cancel button
         self.cancel_button = QPushButton("Cancel", self)
+        self.cancel_button.setEnabled(False)
         self.cancel_button.clicked.connect(self.cancel)
 
         # Setup layout