napari-tmidas 0.1.7.1__py3-none-any.whl → 0.1.8.5__py3-none-any.whl

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/_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/_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):
     """

napari_tmidas/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.7.1'
-__version_tuple__ = version_tuple = (0, 1, 7, 1)
+__version__ = version = '0.1.8.5'
+__version_tuple__ = version_tuple = (0, 1, 8, 5)

napari_tmidas/processing_functions/basic.py

@@ -7,6 +7,37 @@ import numpy as np
 from napari_tmidas._registry import BatchProcessingRegistry
 
 
+@BatchProcessingRegistry.register(
+    name="Labels to Binary",
+    suffix="_binary",
+    description="Convert multi-label images to binary masks (all non-zero labels become 1)",
+)
+def labels_to_binary(image: np.ndarray) -> np.ndarray:
+    """
+    Convert multi-label images to binary masks.
+
+    This function takes a label image (where different regions have different label values)
+    and converts it to a binary mask (where all labeled regions have a value of 1 and
+    background has a value of 0).
+
+    Parameters:
+    -----------
+    image : numpy.ndarray
+        Input label image array
+
+    Returns:
+    --------
+    numpy.ndarray
+        Binary mask with 1 for all non-zero labels and 0 for background
+    """
+    # Make a copy of the input image to avoid modifying the original
+    binary_mask = image.copy()
+
+    binary_mask = (binary_mask > 0).astype(np.uint32)
+
+    return binary_mask
+
+
 @BatchProcessingRegistry.register(
     name="Gamma Correction",
     suffix="_gamma",
@@ -123,3 +154,76 @@ def split_channels(image: np.ndarray, num_channels: int = 3) -> np.ndarray:
     # channels = [np.squeeze(ch, axis=channel_axis) for ch in channels]
 
     return np.stack(channels, axis=0)
+
+
+@BatchProcessingRegistry.register(
+    name="RGB to Labels",
+    suffix="_labels",
+    description="Convert RGB images to label images using a color map",
+    parameters={
+        "blue_label": {
+            "type": int,
+            "default": 1,
+            "min": 0,
+            "max": 255,
+            "description": "Label value for blue objects",
+        },
+        "green_label": {
+            "type": int,
+            "default": 2,
+            "min": 0,
+            "max": 255,
+            "description": "Label value for green objects",
+        },
+        "red_label": {
+            "type": int,
+            "default": 3,
+            "min": 0,
+            "max": 255,
+            "description": "Label value for red objects",
+        },
+    },
+)
+def rgb_to_labels(
+    image: np.ndarray,
+    blue_label: int = 1,
+    green_label: int = 2,
+    red_label: int = 3,
+) -> np.ndarray:
+    """
+    Convert RGB images to label images where each color is mapped to a specific label value.
+
+    Parameters:
+    -----------
+    image : numpy.ndarray
+        Input RGB image array
+    blue_label : int
+        Label value for blue objects (default: 1)
+    green_label : int
+        Label value for green objects (default: 2)
+    red_label : int
+        Label value for red objects (default: 3)
+
+    Returns:
+    --------
+    numpy.ndarray
+        Label image where each color is mapped to the specified label value
+    """
+    # Ensure the image is a proper RGB image
+    if image.ndim < 3 or image.shape[-1] != 3:
+        raise ValueError("Input must be an RGB image with 3 channels")
+
+    # Define the color mapping
+    color_mapping = {
+        (0, 0, 255): blue_label,  # Blue
+        (0, 255, 0): green_label,  # Green
+        (255, 0, 0): red_label,  # Red
+    }
+    # Create an empty label image
+    label_image = np.zeros(image.shape[:-1], dtype=np.uint32)
+    # Iterate through the color mapping and assign labels
+    for color, label in color_mapping.items():
+        mask = np.all(image == color, axis=-1)
+        label_image[mask] = label
+    # Return the label image
+    return label_image