coralnet-toolbox 0.0.73__py2.py3-none-any.whl → 0.0.75__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

@@ -91,9 +91,20 @@ class GlobalEventFilter(QObject):
                 
             # Delete (backspace or delete key) selected annotations when select tool is active
             if event.key() == Qt.Key_Delete or event.key() == Qt.Key_Backspace:
+                # First check if the select tool is active
                 if self.main_window.select_tool_action.isChecked():
+                    selected_tool = self.annotation_window.selected_tool
+                    select_tool = self.annotation_window.tools[selected_tool]
+                    # Get the active subtool if it exists, pass to its keyPressEvent
+                    if hasattr(select_tool, 'active_subtool') and select_tool.active_subtool:
+                        select_tool.active_subtool.keyPressEvent(event)
+                        return True
+                            
+                    # Otherwise, proceed with deletion if there are selected annotations
                     if self.annotation_window.selected_annotations:
                         self.annotation_window.delete_selected_annotations()
+                        return True
+                    
                     # Consume the event so it doesn't do anything else
                     return True
             

coralnet_toolbox/QtImageWindow.py

@@ -1,22 +1,18 @@
 import warnings
 
 import os
-import gc
 from contextlib import contextmanager
 
 import rasterio
 
-from PyQt5.QtGui import QImage, QPixmap
-from PyQt5.QtCore import Qt, pyqtSignal, QTimer, QPoint, QThreadPool, QItemSelectionModel
+from PyQt5.QtCore import Qt, pyqtSignal, QTimer, QPoint, QThreadPool, QItemSelectionModel, QModelIndex
 from PyQt5.QtWidgets import (QSizePolicy, QMessageBox, QCheckBox, QWidget, QVBoxLayout,
                              QLabel, QComboBox, QHBoxLayout, QTableView, QHeaderView, QApplication, 
-                             QMenu, QButtonGroup, QAbstractItemView, QGroupBox, QPushButton, 
-                             QStyle, QFormLayout, QFrame)
-
-from coralnet_toolbox.Rasters import Raster, RasterManager, ImageFilter, RasterTableModel
+                             QMenu, QButtonGroup, QGroupBox, QPushButton, QStyle, 
+                             QFormLayout, QFrame)
 
+from coralnet_toolbox.Rasters import RasterManager, ImageFilter, RasterTableModel
 from coralnet_toolbox.QtProgressBar import ProgressBar
-
 from coralnet_toolbox.Icons import get_icon
 
 
@@ -30,11 +26,24 @@ warnings.filterwarnings("ignore", category=rasterio.errors.NotGeoreferencedWarni
 
 
 class NoArrowKeyTableView(QTableView):
+    # Custom signal to be emitted only on a left-click
+    leftClicked = pyqtSignal(QModelIndex)
+
     def keyPressEvent(self, event):
         if event.key() in (Qt.Key_Up, Qt.Key_Down):
             event.ignore()
             return
         super().keyPressEvent(event)
+
+    def mousePressEvent(self, event):
+        # On a left mouse press, emit our custom signal
+        if event.button() == Qt.LeftButton:
+            index = self.indexAt(event.pos())
+            if index.isValid():
+                self.leftClicked.emit(index)
+        # Call the base class implementation to handle standard behavior
+        # like row selection and context menu triggers.
+        super().mousePressEvent(event)
         
 
 class ImageWindow(QWidget):
@@ -256,10 +265,11 @@ class ImageWindow(QWidget):
         self.table_model = RasterTableModel(self.raster_manager, self)
         self.tableView.setModel(self.table_model)
         
-        # Set column widths - removed checkbox column, adjust accordingly
-        self.tableView.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
-        self.tableView.setColumnWidth(1, 120)
-        self.tableView.horizontalHeader().setSectionResizeMode(1, QHeaderView.Fixed)
+        # Set column widths
+        self.tableView.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)  # Checkmark column
+        self.tableView.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)  # Filename column
+        self.tableView.setColumnWidth(2, 120)  # Annotation column
+        self.tableView.horizontalHeader().setSectionResizeMode(2, QHeaderView.Fixed)
         
         # Style the header
         self.tableView.horizontalHeader().setStyleSheet("""
@@ -271,7 +281,7 @@ class ImageWindow(QWidget):
         """)
         
         # Connect signals for clicking
-        self.tableView.pressed.connect(self.on_table_pressed)
+        self.tableView.leftClicked.connect(self.on_table_pressed)
         self.tableView.doubleClicked.connect(self.on_table_double_clicked)
         
         # Add table view to the layout
@@ -413,59 +423,62 @@ class ImageWindow(QWidget):
     #
     
     def on_table_pressed(self, index):
-        """Handle a single click on the table view."""
+        """Handle a single left-click on the table view with complex modifier support."""
         if not index.isValid():
             return
-        
-        # Get the path at the clicked row
+
         path = self.table_model.get_path_at_row(index.row())
         if not path:
             return
         
-        # Get keyboard modifiers
         modifiers = QApplication.keyboardModifiers()
-        
-        # Handle highlighting logic
-        if modifiers & Qt.ControlModifier:
-            # Ctrl+Click: Toggle highlight for the clicked row
+        current_row = index.row()
+
+        # Define conditions for modifiers
+        has_ctrl = bool(modifiers & Qt.ControlModifier)
+        has_shift = bool(modifiers & Qt.ShiftModifier)
+
+        if has_shift:
+            # This block handles both Shift+Click and Ctrl+Shift+Click.
+            # First, determine the paths in the selection range.
+            range_paths = []
+            if self.last_highlighted_row >= 0:
+                start = min(self.last_highlighted_row, current_row)
+                end = max(self.last_highlighted_row, current_row)
+                for r in range(start, end + 1):
+                    p = self.table_model.get_path_at_row(r)
+                    if p:
+                        range_paths.append(p)
+            else:
+                # If there's no anchor, the range is just the clicked item.
+                range_paths.append(path)
+
+            if not has_ctrl:
+                # Case 1: Simple Shift+Click. Clears previous highlights 
+                # and selects only the new range.
+                self.table_model.set_highlighted_paths(range_paths)
+            else:
+                # Case 2: Ctrl+Shift+Click. Adds the new range to the
+                # existing highlighted rows without clearing them.
+                for p in range_paths:
+                    self.table_model.highlight_path(p, True)
+        
+        elif has_ctrl:
+            # Case 3: Ctrl+Click. Toggles a single row's highlight state
+            # and sets it as the new anchor for future shift-clicks.
             raster = self.raster_manager.get_raster(path)
             if raster:
                 self.table_model.highlight_path(path, not raster.is_highlighted)
-                # Update highlighted count
-                self.update_highlighted_count_label()
-                
-        elif modifiers & Qt.ShiftModifier:
-            # Shift+Click: Highlight range from last highlighted to current
-            if self.last_highlighted_row >= 0:
-                # Get the current row and last highlighted row
-                current_row = index.row()
-                
-                # Calculate range (handle both directions)
-                start_row = min(self.last_highlighted_row, current_row)
-                end_row = max(self.last_highlighted_row, current_row)
-                
-                # Highlight the range
-                for row in range(start_row, end_row + 1):
-                    path_to_highlight = self.table_model.get_path_at_row(row)
-                    if path_to_highlight:
-                        self.table_model.highlight_path(path_to_highlight, True)
-            else:
-                # No previous selection, just highlight the current row
-                self.table_model.highlight_path(path, True)
-                
-            # Update the last highlighted row
-            self.last_highlighted_row = index.row()
-            
-            # Update highlighted count
-            self.update_highlighted_count_label()
+            self.last_highlighted_row = current_row
+        
         else:
-            # Regular click: Clear all highlights and highlight only this row
-            self.table_model.clear_highlights()
-            self.table_model.highlight_path(path, True)
-            self.last_highlighted_row = index.row()
-            
-            # Update highlighted count
-            self.update_highlighted_count_label()
+            # Case 4: Plain Click. Clears everything and highlights only
+            # the clicked row, setting it as the new anchor.
+            self.table_model.set_highlighted_paths([path])
+            self.last_highlighted_row = current_row
+        
+        # Finally, update the count label after any changes.
+        self.update_highlighted_count_label()
 
     def on_table_double_clicked(self, index):
         """Handle double click on table view (selects image and loads it)."""
@@ -521,6 +534,24 @@ class ImageWindow(QWidget):
         """Handler for when an image is loaded."""
         self.selected_image_path = path
         
+    def on_toggle(self, new_state: bool):
+            """
+            Sets the checked state for all currently highlighted rows.
+
+            Args:
+                new_state (bool): The new state to set (True for checked, False for unchecked).
+            """
+            highlighted_paths = self.table_model.get_highlighted_paths()
+            if not highlighted_paths:
+                return
+
+            for path in highlighted_paths:
+                raster = self.raster_manager.get_raster(path)
+                if raster:
+                    raster.checkbox_state = new_state
+                    # Notify the model to update the view for this specific raster
+                    self.table_model.update_raster_data(path)
+            
     #
     # Public methods
     #
@@ -547,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()
@@ -960,28 +987,46 @@ class ImageWindow(QWidget):
         
     def show_context_menu(self, position):
         """
-        Show the context menu for the table.
+        Show the context menu for the table, including the toggle check state action.
         
         Args:
             position (QPoint): Position to show the menu
         """
+        # Get the path corresponding to the right-clicked row
+        index = self.tableView.indexAt(position)
+        path_at_cursor = self.table_model.get_path_at_row(index.row()) if index.isValid() else None
+
+        # Get the currently highlighted paths from the model
         highlighted_paths = self.table_model.get_highlighted_paths()
-        if not highlighted_paths:
-            # If no highlights, highlight the row under the cursor only
-            index = self.tableView.indexAt(position)
-            if index.isValid():
-                path = self.table_model.get_path_at_row(index.row())
-                if path:
-                    self.table_model.set_highlighted_paths([path])
-                    self.last_highlighted_row = index.row()
-                    highlighted_paths = [path]
-        else:
-            # If any highlights, ensure all highlighted rows are used (no change needed)
-            self.table_model.set_highlighted_paths(highlighted_paths)
+
+        # If the user right-clicked on a row that wasn't already highlighted,
+        # then we assume they want to act on this row alone.
+        if path_at_cursor and path_at_cursor not in highlighted_paths:
+            self.table_model.set_highlighted_paths([path_at_cursor])
+            self.last_highlighted_row = index.row()
+            highlighted_paths = [path_at_cursor]
+        
+        # If no rows are highlighted, do nothing.
         if not highlighted_paths:
             return
+
         context_menu = QMenu(self)
         count = len(highlighted_paths)
+        
+        # Add the check/uncheck action
+        raster_under_cursor = self.raster_manager.get_raster(path_at_cursor)
+        if raster_under_cursor:
+            is_checked = raster_under_cursor.checkbox_state
+            if is_checked:
+                action_text = f"Uncheck {count} Highlighted Image{'s' if count > 1 else ''}"
+            else:
+                action_text = f"Check {count} Highlighted Image{'s' if count > 1 else ''}"
+            toggle_check_action = context_menu.addAction(action_text)
+            toggle_check_action.triggered.connect(lambda: self.on_toggle(not is_checked))
+
+        context_menu.addSeparator()
+
+        # Add existing delete actions
         delete_images_action = context_menu.addAction(f"Delete {count} Highlighted Image{'s' if count > 1 else ''}")
         delete_images_action.triggered.connect(lambda: self.delete_highlighted_images())
         delete_annotations_action = context_menu.addAction(

coralnet_toolbox/QtLabelWindow.py

@@ -485,7 +485,19 @@ class LabelWindow(QWidget):
         self.scroll_content.setFixedWidth(self.labels_per_row * self.label_width)
 
     def reorganize_labels(self):
-        """Rearrange labels in the grid layout based on the current order and labels_per_row."""
+        """
+        Rearrange labels in the grid layout based on the current order and labels_per_row.
+        """
+        # First, clear the existing layout to remove any lingering widgets.
+        # This prevents references to deleted widgets from persisting in the layout.
+        while self.grid_layout.count():
+            item = self.grid_layout.takeAt(0)
+            widget = item.widget()
+            if widget:
+                # Setting the parent to None removes the widget from the layout's control.
+                widget.setParent(None)
+
+        # Now, add the current labels from the model back into the clean layout.
         for i, label in enumerate(self.labels):
             row = i // self.labels_per_row
             col = i % self.labels_per_row

coralnet_toolbox/QtMainWindow.py

@@ -2290,34 +2290,10 @@ class MainWindow(QMainWindow):
                                 "No images are present in the project.")
             return
         
-        if not self.annotation_window.annotations_dict:
+        if len(self.label_window.labels) <= 1:
             QMessageBox.warning(self,
                                 "See Anything (YOLOE)",
-                                "No annotations are present in the project.")
-            return
-        
-        valid_reference_types = {"PolygonAnnotation", "RectangleAnnotation"}
-        has_valid_reference = False
-
-        # Iterate through the rasters in the main manager.
-        for raster in self.image_window.raster_manager.rasters.values():
-            # The values of our map are sets of annotation type names.
-            # e.g., [{'PointAnnotation'}, {'PolygonAnnotation', 'RectangleAnnotation'}]
-            for types_for_a_label in raster.label_to_types_map.values():
-                # Check if the set of types for this specific label
-                # has any overlap with our valid reference types.
-                if not valid_reference_types.isdisjoint(types_for_a_label):
-                    # A valid reference type was found for at least one label on this raster.
-                    has_valid_reference = True
-                    break  # Exit the inner loop (over types)
-            
-            if has_valid_reference:
-                break  # Exit the outer loop (over rasters)
-
-        if not has_valid_reference:
-            QMessageBox.warning(self,
-                                "No Valid Reference Annotations",
-                                "No images have polygon or rectangle annotations to use as a reference.")
+                                "At least one reference label is required for reference.")
             return
 
         try:
@@ -2518,7 +2494,9 @@ class MainWindow(QMainWindow):
             msg.setWindowIcon(self.coral_icon)
             msg.setWindowTitle("GDI Limit Reached")
             msg.setText(
-                "The GDI limit has been reached! Please immediately save your work, close, and reopen the application!"
+                "The GDI limit is getting dangerously close to being reached (this is a known issue). "
+                "Please immediately save your progress, close, and re-open the application. Failure to do so may "
+                "result in data loss."
             )
             msg.setStandardButtons(QMessageBox.Ok)
             msg.exec_()