napari-tmidas 0.1.8__tar.gz → 0.1.8.5__tar.gz

{napari_tmidas-0.1.8 → napari_tmidas-0.1.8.5}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: napari-tmidas
-Version: 0.1.8
-Summary: Tissue Microscopy Image Data Analysis Suite
+Version: 0.1.8.5
+Summary: A plugin for batch processing of confocal microscopy images
 Author: Marco Meer
 Author-email: marco.meer@pm.me
 License: 
@@ -58,6 +58,14 @@ Requires-Dist: magicgui
 Requires-Dist: qtpy
 Requires-Dist: scikit-image
 Requires-Dist: pyqt5
+Requires-Dist: tqdm
+Requires-Dist: scikit-image
+Requires-Dist: ome-zarr
+Requires-Dist: napari-ome-zarr
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: timm
+Requires-Dist: opencv-python
 Provides-Extra: testing
 Requires-Dist: tox; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
@@ -80,7 +88,15 @@ The `napari-tmidas` plugin consists of a growing collection of pipelines for fas
 ## Feature Overview
 
 1. **Image Processing**
-   - Process image folders with: Gamma correction, Z-projection, channel splitting, Gaussian/median filters, thresholding (Otsu/manual), and label cleaning
+   - Process image folders with:
+     - Gamma correction & histogram equalization
+     - Z-projection and channel splitting
+     - Gaussian & median filters
+     - Thresholding (Otsu/manual)
+     - Label cleaning & binary conversion
+     - RGB to labels conversion
+     - Cellpose 3.0 automated segmentation
+     - File compression (Zstandard)
 
 2. **Label Inspection**
    - Review and edit label images with auto-save
@@ -112,19 +128,27 @@ Now you can install `napari-tmidas` via [pip]:
 
     pip install napari-tmidas
 
-To install the latest development version:
+It is recommended to install the latest development version:
 
     pip install git+https://github.com/macromeer/napari-tmidas.git
 
 ### Dependencies
-To use the Batch Microscopy Image Conversion pipeline, we need some libraries to read microscopy formats and to write ome-zarr:
 
-    pip install nd2 readlif tiffslide pylibCZIrw acquifer-napari ome-zarr napari-ome-zarr
+To use the Batch Microscopy Image Conversion pipeline, we need some libraries to read microscopy formats:
+
+    pip install nd2 readlif tiffslide pylibCZIrw acquifer-napari
 
 For the Batch Crop Anything pipeline, we need to install MobileSAM and its dependencies:
 
     pip install git+https://github.com/ChaoningZhang/MobileSAM.git
-    pip install torch torchvision timm opencv-python
+
+
+If you want to batch compress images using [Zstandard](https://github.com/facebook/zstd), use the package manager of your operating system to install it:
+
+    sudo apt-get install zstd    # for Linux
+    brew install zstd            # for macOS
+    choco install zstandard      # for Windows
+
 
 ## Usage
 
@@ -169,9 +193,9 @@ If you have already segmented a folder full of images and now you want to maybe
 ![image](https://github.com/user-attachments/assets/0bf8c6ae-4212-449d-8183-e91b23ba740e)
 
 ### Crop Anything
-This pipeline combines the Segment Anything Model (SAM) for automatic object detection with an interactive interface for selecting and cropping multiple objects from images. To launch the widget, open `Plugins > T-MIDAS > Batch Crop Anything`
+This pipeline combines the Segment Anything Model (SAM) for automatic object detection with an interactive interface for selecting and cropping multiple objects from images. To launch the widget, open `Plugins > T-MIDAS > Batch Crop Anything`. Click the image below to see a video demo.
 
-![image](https://github.com/user-attachments/assets/6d72c2a2-1064-4a27-b398-a9b86fcbc443)
+[![image](https://github.com/user-attachments/assets/6d72c2a2-1064-4a27-b398-a9b86fcbc443)](https://youtu.be/xPh0dRD_FbE)
 
 ### ROI Colocalization
 This pipeline quantifies colocalization between labeled regions of interest (ROIs) across multiple image channels. It determines the extent of overlap between ROIs in a reference channel and those in one or two other channels. The output is a table of colocalization counts. Optionally, the size of reference channel ROIs, as well as the total or median size of colocalizing ROIs in the other channels, can be included. Colocalization is determined using Boolean masking. The number of colocalizing instances is determined by counting unique label IDs within the overlapping regions. Typically, the reference channel contains larger structures, while other channels contain smaller, potentially nested, structures. For example, the reference channel might contain cell bodies, with the second and third channels containing nuclei and sub-nuclear objects, respectively.

{napari_tmidas-0.1.8 → napari_tmidas-0.1.8.5}/README.md

@@ -11,7 +11,15 @@ The `napari-tmidas` plugin consists of a growing collection of pipelines for fas
 ## Feature Overview
 
 1. **Image Processing**
-   - Process image folders with: Gamma correction, Z-projection, channel splitting, Gaussian/median filters, thresholding (Otsu/manual), and label cleaning
+   - Process image folders with:
+     - Gamma correction & histogram equalization
+     - Z-projection and channel splitting
+     - Gaussian & median filters
+     - Thresholding (Otsu/manual)
+     - Label cleaning & binary conversion
+     - RGB to labels conversion
+     - Cellpose 3.0 automated segmentation
+     - File compression (Zstandard)
 
 2. **Label Inspection**
    - Review and edit label images with auto-save
@@ -43,19 +51,27 @@ Now you can install `napari-tmidas` via [pip]:
 
     pip install napari-tmidas
 
-To install the latest development version:
+It is recommended to install the latest development version:
 
     pip install git+https://github.com/macromeer/napari-tmidas.git
 
 ### Dependencies
-To use the Batch Microscopy Image Conversion pipeline, we need some libraries to read microscopy formats and to write ome-zarr:
 
-    pip install nd2 readlif tiffslide pylibCZIrw acquifer-napari ome-zarr napari-ome-zarr
+To use the Batch Microscopy Image Conversion pipeline, we need some libraries to read microscopy formats:
+
+    pip install nd2 readlif tiffslide pylibCZIrw acquifer-napari
 
 For the Batch Crop Anything pipeline, we need to install MobileSAM and its dependencies:
 
     pip install git+https://github.com/ChaoningZhang/MobileSAM.git
-    pip install torch torchvision timm opencv-python
+
+
+If you want to batch compress images using [Zstandard](https://github.com/facebook/zstd), use the package manager of your operating system to install it:
+
+    sudo apt-get install zstd    # for Linux
+    brew install zstd            # for macOS
+    choco install zstandard      # for Windows
+
 
 ## Usage
 
@@ -100,9 +116,9 @@ If you have already segmented a folder full of images and now you want to maybe
 ![image](https://github.com/user-attachments/assets/0bf8c6ae-4212-449d-8183-e91b23ba740e)
 
 ### Crop Anything
-This pipeline combines the Segment Anything Model (SAM) for automatic object detection with an interactive interface for selecting and cropping multiple objects from images. To launch the widget, open `Plugins > T-MIDAS > Batch Crop Anything`
+This pipeline combines the Segment Anything Model (SAM) for automatic object detection with an interactive interface for selecting and cropping multiple objects from images. To launch the widget, open `Plugins > T-MIDAS > Batch Crop Anything`. Click the image below to see a video demo.
 
-![image](https://github.com/user-attachments/assets/6d72c2a2-1064-4a27-b398-a9b86fcbc443)
+[![image](https://github.com/user-attachments/assets/6d72c2a2-1064-4a27-b398-a9b86fcbc443)](https://youtu.be/xPh0dRD_FbE)
 
 ### ROI Colocalization
 This pipeline quantifies colocalization between labeled regions of interest (ROIs) across multiple image channels. It determines the extent of overlap between ROIs in a reference channel and those in one or two other channels. The output is a table of colocalization counts. Optionally, the size of reference channel ROIs, as well as the total or median size of colocalizing ROIs in the other channels, can be included. Colocalization is determined using Boolean masking. The number of colocalizing instances is determined by counting unique label IDs within the overlapping regions. Typically, the reference channel contains larger structures, while other channels contain smaller, potentially nested, structures. For example, the reference channel might contain cell bodies, with the second and third channels containing nuclei and sub-nuclear objects, respectively.

{napari_tmidas-0.1.8 → napari_tmidas-0.1.8.5}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "napari-tmidas"
 dynamic = ["version"]
-description = "Tissue Microscopy Image Data Analysis Suite"
+description = "A plugin for batch processing of confocal microscopy images"
 readme = "README.md"
 license = {file = "LICENSE"}
 authors = [
@@ -30,6 +30,14 @@ dependencies = [
     "qtpy",
     "scikit-image",
     "pyqt5",
+    "tqdm",
+    "scikit-image",
+    "ome-zarr",
+    "napari-ome-zarr",
+    "torch",
+    "torchvision",
+    "timm",
+    "opencv-python",
 ]
 
 [project.optional-dependencies]

{napari_tmidas-0.1.8 → napari_tmidas-0.1.8.5}/src/napari_tmidas/_crop_anything.py

@@ -29,6 +29,7 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 from skimage.io import imread
+from skimage.transform import resize  # Added import for resize function
 from tifffile import imwrite
 
 
@@ -48,6 +49,7 @@ class BatchCropAnything:
         self.original_image = None
         self.segmentation_result = None
         self.current_image_for_segmentation = None
+        self.current_scale_factor = 1.0  # Added scale factor tracking
 
         # UI references
         self.image_layer = None
@@ -356,10 +358,41 @@ class BatchCropAnything:
             # Convert back to uint8
             image_gamma = (image_gamma * 255).astype(np.uint8)
 
+            # Check if the image is very large and needs downscaling
+            orig_shape = image_gamma.shape[:2]  # (height, width)
+
+            # Calculate image size in megapixels
+            image_mp = (orig_shape[0] * orig_shape[1]) / 1e6
+
+            # If image is larger than 2 megapixels, downscale it
+            max_mp = 2.0  # Maximum image size in megapixels
+            scale_factor = 1.0
+
+            if image_mp > max_mp:
+                scale_factor = np.sqrt(max_mp / image_mp)
+                new_height = int(orig_shape[0] * scale_factor)
+                new_width = int(orig_shape[1] * scale_factor)
+
+                self.viewer.status = f"Downscaling image from {orig_shape} to {(new_height, new_width)} for processing (scale: {scale_factor:.2f})"
+
+                # Resize the image for processing
+                image_gamma_resized = resize(
+                    image_gamma,
+                    (new_height, new_width),
+                    anti_aliasing=True,
+                    preserve_range=True,
+                ).astype(np.uint8)
+
+                # Store scale factor for later use
+                self.current_scale_factor = scale_factor
+            else:
+                image_gamma_resized = image_gamma
+                self.current_scale_factor = 1.0
+
             self.viewer.status = f"Generating segmentation with sensitivity {self.sensitivity} (gamma={gamma:.2f})..."
 
-            # Generate masks with gamma-corrected image
-            masks = self.mask_generator.generate(image_gamma)
+            # Generate masks with gamma-corrected and potentially resized image
+            masks = self.mask_generator.generate(image_gamma_resized)
             self.viewer.status = f"Generated {len(masks)} masks"
 
             if not masks:
@@ -390,9 +423,16 @@ class BatchCropAnything:
                 return
 
             # Process segmentation masks
-            self._process_segmentation_masks(
-                masks, self.current_image_for_segmentation.shape[:2]
-            )
+            # If image was downscaled, we need to ensure masks are upscaled correctly
+            if self.current_scale_factor < 1.0:
+                # Upscale the segmentation masks to match the original image dimensions
+                self._process_segmentation_masks_with_scaling(
+                    masks, self.current_image_for_segmentation.shape[:2]
+                )
+            else:
+                self._process_segmentation_masks(
+                    masks, self.current_image_for_segmentation.shape[:2]
+                )
 
             # Clear selected labels since segmentation has changed
             self.selected_labels = set()
@@ -475,6 +515,98 @@ class BatchCropAnything:
         # image_name = os.path.basename(self.images[self.current_index])
         self.viewer.status = f"Loaded image {self.current_index + 1}/{len(self.images)} - Found {len(masks)} segments"
 
+    # New method for handling scaled segmentation masks
+    def _process_segmentation_masks_with_scaling(self, masks, original_shape):
+        """Process segmentation masks with scaling to match the original image size."""
+        # Create label image from masks
+        # First determine the size of the mask predictions (which are at the downscaled resolution)
+        if not masks:
+            return
+
+        mask_shape = masks[0]["segmentation"].shape
+
+        # Create an empty label image at the downscaled resolution
+        downscaled_labels = np.zeros(mask_shape, dtype=np.uint32)
+        self.label_info = {}  # Reset label info
+
+        # Fill in the downscaled labels
+        for i, mask_data in enumerate(masks):
+            mask = mask_data["segmentation"]
+            label_id = i + 1  # Start label IDs from 1
+            downscaled_labels[mask] = label_id
+
+            # Store basic label info
+            area = np.sum(mask)
+            y_indices, x_indices = np.where(mask)
+            center_y = np.mean(y_indices) if len(y_indices) > 0 else 0
+            center_x = np.mean(x_indices) if len(x_indices) > 0 else 0
+
+            # Scale centers to original image coordinates
+            center_y_orig = center_y / self.current_scale_factor
+            center_x_orig = center_x / self.current_scale_factor
+
+            # Store label info at original scale
+            self.label_info[label_id] = {
+                "area": area
+                / (
+                    self.current_scale_factor**2
+                ),  # Approximate area in original scale
+                "center_y": center_y_orig,
+                "center_x": center_x_orig,
+                "score": mask_data.get("stability_score", 0),
+            }
+
+        # Upscale the labels to the original image size
+        upscaled_labels = resize(
+            downscaled_labels,
+            original_shape,
+            order=0,  # Nearest neighbor interpolation
+            preserve_range=True,
+            anti_aliasing=False,
+        ).astype(np.uint32)
+
+        # Sort labels by area (largest first)
+        self.label_info = dict(
+            sorted(
+                self.label_info.items(),
+                key=lambda item: item[1]["area"],
+                reverse=True,
+            )
+        )
+
+        # Save segmentation result
+        self.segmentation_result = upscaled_labels
+
+        # Remove existing label layer if exists
+        for layer in list(self.viewer.layers):
+            if isinstance(layer, Labels) and "Segmentation" in layer.name:
+                self.viewer.layers.remove(layer)
+
+        # Add label layer to viewer
+        self.label_layer = self.viewer.add_labels(
+            upscaled_labels,
+            name=f"Segmentation ({os.path.basename(self.images[self.current_index])})",
+            opacity=0.7,
+        )
+
+        # Make the label layer active by default
+        self.viewer.layers.selection.active = self.label_layer
+
+        # Disconnect existing callbacks if any
+        if (
+            hasattr(self, "label_layer")
+            and self.label_layer is not None
+            and hasattr(self.label_layer, "mouse_drag_callbacks")
+        ):
+            # Remove old callbacks
+            for callback in list(self.label_layer.mouse_drag_callbacks):
+                self.label_layer.mouse_drag_callbacks.remove(callback)
+
+        # Connect mouse click event to label selection
+        self.label_layer.mouse_drag_callbacks.append(self._on_label_clicked)
+
+        self.viewer.status = f"Loaded image {self.current_index + 1}/{len(self.images)} - Found {len(masks)} segments"
+
     # --------------------------------------------------
     # Label Selection and UI Elements
     # --------------------------------------------------

{napari_tmidas-0.1.8 → napari_tmidas-0.1.8.5}/src/napari_tmidas/_file_conversion.py

@@ -1105,19 +1105,21 @@ class ConversionWorker(QThread):
                 )
                 file_size_GB = estimated_size_bytes / (1024**3)
 
-                # If file is very large (>4GB), force zarr format regardless of setting
+                # Determine format
                 use_zarr = self.use_zarr
-                if file_size_GB > 4:
-                    use_zarr = True
-                    if not self.use_zarr:
-                        print(
-                            f"File size ({file_size_GB:.2f}GB) exceeds 4GB limit for TIF, automatically using ZARR format"
-                        )
-                        self.file_done.emit(
-                            filepath,
-                            True,
-                            f"File size ({file_size_GB:.2f}GB) exceeds 4GB, using ZARR format",
-                        )
+                # If file is very large (>4GB) and user didn't explicitly choose TIF,
+                # auto-switch to ZARR format
+                if file_size_GB > 4 and not self.use_zarr:
+                    # Recommend ZARR format but respect user's choice by still allowing TIF
+                    print(
+                        f"File size ({file_size_GB:.2f}GB) exceeds 4GB, ZARR format is recommended but using TIF with BigTIFF format"
+                    )
+                    self.file_done.emit(
+                        filepath,
+                        True,
+                        f"File size ({file_size_GB:.2f}GB) exceeds 4GB, using TIF with BigTIFF format",
+                    )
+
                 # Set up the output path
                 if use_zarr:
                     output_path = os.path.join(
@@ -1171,12 +1173,22 @@ class ConversionWorker(QThread):
     def _save_tif(
         self, image_data: np.ndarray, output_path: str, metadata: dict = None
     ):
-        """Enhanced TIF saving with proper dimension handling"""
+        """Enhanced TIF saving with proper dimension handling and BigTIFF support"""
         import tifffile
 
         print(f"Saving TIF file: {output_path}")
         print(f"Image data shape: {image_data.shape}")
 
+        # Check if this is a large file that needs BigTIFF
+        estimated_size_bytes = np.prod(image_data.shape) * image_data.itemsize
+        file_size_GB = estimated_size_bytes / (1024**3)
+        use_bigtiff = file_size_GB > 4
+
+        if use_bigtiff:
+            print(
+                f"File size ({file_size_GB:.2f}GB) exceeds 4GB, using BigTIFF format"
+            )
+
         if metadata:
             print(f"Metadata keys: {list(metadata.keys())}")
             if "axes" in metadata:
@@ -1198,7 +1210,12 @@ class ConversionWorker(QThread):
         # Basic save if no metadata
         if metadata is None:
             print("No metadata provided, using basic save")
-            tifffile.imwrite(output_path, image_data, compression="zstd")
+            tifffile.imwrite(
+                output_path,
+                image_data,
+                compression="zlib",
+                bigtiff=use_bigtiff,
+            )
             return
 
         # Get image dimensions and axis order
@@ -1261,7 +1278,10 @@ class ConversionWorker(QThread):
                     print(f"Error reordering dimensions: {e}")
                     # Fall back to simple save without reordering
                     tifffile.imwrite(
-                        output_path, image_data, compression="zstd"
+                        output_path,
+                        image_data,
+                        compression="zlib",
+                        bigtiff=use_bigtiff,
                     )
                     return
 
@@ -1287,7 +1307,8 @@ class ConversionWorker(QThread):
                     output_path,
                     image_data,
                     resolution=resolution,
-                    compression="zstd",
+                    compression="zlib",
+                    bigtiff=use_bigtiff,
                 )
             else:
                 # Hyperstack case
@@ -1306,14 +1327,15 @@ class ConversionWorker(QThread):
                     imagej=True,
                     resolution=resolution,
                     metadata=imagej_metadata,
-                    compression="zstd",
+                    compression="zlib",
+                    bigtiff=use_bigtiff,
                 )
 
             print(f"Successfully saved TIF file: {output_path}")
         except (ValueError, FileNotFoundError) as e:
             print(f"Error saving TIF file: {e}")
             # Try simple save as fallback
-            tifffile.imwrite(output_path, image_data)
+            tifffile.imwrite(output_path, image_data, bigtiff=use_bigtiff)
 
     def _save_zarr(
         self, image_data: np.ndarray, output_path: str, metadata: dict = None

{napari_tmidas-0.1.8 → napari_tmidas-0.1.8.5}/src/napari_tmidas/_file_selector.py

@@ -603,15 +603,29 @@ class ProcessingWorker(QThread):
         self.processing_finished.emit()
 
     def process_file(self, filepath):
-        """Process a single file"""
+        """Process a single file with support for large TIFF files and removal of all singleton dimensions"""
         try:
             # Load the image
             image = imread(filepath)
             image_dtype = image.dtype
 
+            print(f"Original image shape: {image.shape}, dtype: {image_dtype}")
+
             # Apply processing with parameters
             processed_image = self.processing_func(image, **self.param_values)
 
+            print(
+                f"Processed image shape before removing singletons: {processed_image.shape}, dtype: {processed_image.dtype}"
+            )
+
+            # Remove ALL singleton dimensions from the processed image
+            # This will keep only dimensions with size > 1
+            processed_image = np.squeeze(processed_image)
+
+            print(
+                f"Processed image shape after removing singletons: {processed_image.shape}"
+            )
+
             # Generate new filename base
             filename = os.path.basename(filepath)
             name, ext = os.path.splitext(filename)
@@ -619,33 +633,91 @@ class ProcessingWorker(QThread):
                 name.replace(self.input_suffix, "") + self.output_suffix
             )
 
-            # Check if the processed image is a stacked array
-            if processed_image.ndim > image.ndim:
+            # Check if the first dimension should be treated as channels
+            # If processed_image has more dimensions than the original image,
+            # assume the first dimension represents channels
+            is_multi_channel = (processed_image.ndim > image.ndim - 1) or (
+                processed_image.ndim == image.ndim
+                and processed_image.shape[0] <= 10
+            )
+
+            if (
+                is_multi_channel and processed_image.shape[0] <= 10
+            ):  # Reasonable number of channels
                 # Save each channel as a separate image
                 processed_files = []
-                for i in range(processed_image.shape[0]):
+
+                num_channels = processed_image.shape[0]
+                print(
+                    f"Treating first dimension as channels. Saving {num_channels} separate channel files"
+                )
+
+                for i in range(num_channels):
                     channel_filename = f"{new_filename_base}_channel_{i}{ext}"
                     channel_filepath = os.path.join(
                         self.output_folder, channel_filename
                     )
 
+                    # Extract channel data and remove any remaining singleton dimensions
+                    channel_image = np.squeeze(processed_image[i])
+
+                    print(f"Channel {i} shape: {channel_image.shape}")
+
+                    # Calculate approx file size in GB
+                    size_gb = (
+                        channel_image.size * channel_image.itemsize / (1024**3)
+                    )
+                    print(f"Estimated file size: {size_gb:.2f} GB")
+
+                    # Check data range
+                    data_min = (
+                        np.min(channel_image) if channel_image.size > 0 else 0
+                    )
+                    data_max = (
+                        np.max(channel_image) if channel_image.size > 0 else 0
+                    )
+                    print(f"Channel {i} data range: {data_min} to {data_max}")
+
+                    # For very large files, we need to use BigTIFF format
+                    use_bigtiff = (
+                        size_gb > 2.0
+                    )  # Use BigTIFF for files over 2GB
+
                     if (
                         "labels" in channel_filename
                         or "semantic" in channel_filename
                     ):
+                        # Choose appropriate integer type based on data range
+                        if data_max <= 255:
+                            save_dtype = np.uint8
+                        elif data_max <= 65535:
+                            save_dtype = np.uint16
+                        else:
+                            save_dtype = np.uint32
+
+                        print(
+                            f"Label image detected, saving as {save_dtype.__name__} with bigtiff={use_bigtiff}"
+                        )
                         tifffile.imwrite(
                             channel_filepath,
-                            processed_image[i].astype(np.uint32),
+                            channel_image.astype(save_dtype),
                             compression="zlib",
+                            bigtiff=use_bigtiff,
                         )
                     else:
-                        # First remove singletons
-                        channel_image = np.squeeze(processed_image[i])
+                        # Handle large images with bigtiff format
+                        print(
+                            f"Regular image channel, saving with dtype {image_dtype} and bigtiff={use_bigtiff}"
+                        )
+
+                        # Save with original dtype and bigtiff format if needed
                         tifffile.imwrite(
                             channel_filepath,
                             channel_image.astype(image_dtype),
                             compression="zlib",
+                            bigtiff=use_bigtiff,
                         )
+
                     processed_files.append(channel_filepath)
 
                 # Return processing info
@@ -654,25 +726,61 @@ class ProcessingWorker(QThread):
                     "processed_files": processed_files,
                 }
             else:
-                # Save as a single image (original behavior)
+                # Save as a single image
                 new_filepath = os.path.join(
                     self.output_folder, new_filename_base + ext
                 )
 
+                print(f"Single output image shape: {processed_image.shape}")
+
+                # Calculate approx file size in GB
+                size_gb = (
+                    processed_image.size * processed_image.itemsize / (1024**3)
+                )
+                print(f"Estimated file size: {size_gb:.2f} GB")
+
+                # For very large files, we need to use BigTIFF format
+                use_bigtiff = size_gb > 2.0  # Use BigTIFF for files over 2GB
+
+                # Check data range
+                data_min = (
+                    np.min(processed_image) if processed_image.size > 0 else 0
+                )
+                data_max = (
+                    np.max(processed_image) if processed_image.size > 0 else 0
+                )
+                print(f"Data range: {data_min} to {data_max}")
+
                 if (
                     "labels" in new_filename_base
                     or "semantic" in new_filename_base
                 ):
+                    # Choose appropriate integer type based on data range
+                    if data_max <= 255:
+                        save_dtype = np.uint8
+                    elif data_max <= 65535:
+                        save_dtype = np.uint16
+                    else:
+                        save_dtype = np.uint32
+
+                    print(
+                        f"Saving label image as {save_dtype.__name__} with bigtiff={use_bigtiff}"
+                    )
                     tifffile.imwrite(
                         new_filepath,
-                        processed_image.astype(np.uint32),
+                        processed_image.astype(save_dtype),
                         compression="zlib",
+                        bigtiff=use_bigtiff,
                     )
                 else:
+                    print(
+                        f"Saving image with dtype {image_dtype} and bigtiff={use_bigtiff}"
+                    )
                     tifffile.imwrite(
                         new_filepath,
                         processed_image.astype(image_dtype),
                         compression="zlib",
+                        bigtiff=use_bigtiff,
                     )
 
                 # Return processing info
@@ -684,6 +792,9 @@ class ProcessingWorker(QThread):
         except Exception as e:
             # Log the error and re-raise to be caught by the executor
             print(f"Error processing {filepath}: {e}")
+            import traceback
+
+            traceback.print_exc()
             raise
         finally:
             # Explicit cleanup to help with memory management
@@ -692,10 +803,6 @@ class ProcessingWorker(QThread):
             if "processed_image" in locals():
                 del processed_image
 
-    def stop(self):
-        """Request worker to stop processing"""
-        self.stop_requested = True
-
 
 class FileResultsWidget(QWidget):
     """