napari-tmidas 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

napari_tmidas/_file_conversion.py

@@ -1,16 +1,29 @@
+"""
+Batch Microscopy Image File Conversion
+=======================================
+This module provides a GUI for batch conversion of microscopy image files to a common format.
+The user can select a folder containing microscopy image files, preview the images, and convert them to an open format for image processing.
+The supported input formats include Leica LIF, Nikon ND2, Zeiss CZI, and TIFF-based whole slide images (NDPI, etc.).
+
+"""
+
 import concurrent.futures
 import os
 import re
+import shutil
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
+import dask.array as da
 import napari
 import nd2  # https://github.com/tlambert03/nd2
 import numpy as np
 import tifffile
 import zarr
+from dask.diagnostics import ProgressBar
 from magicgui import magicgui
-from ome_zarr.writer import write_image  # https://github.com/ome/ome-zarr-py
+from ome_zarr.io import parse_url
+from ome_zarr.writer import write_image
 from pylibCZIrw import czi  # https://github.com/ZEISS/pylibczirw
 from qtpy.QtCore import Qt, QThread, Signal
 from qtpy.QtWidgets import (
@@ -183,17 +196,30 @@ class SeriesDetailWidget(QWidget):
 
                 # Set info text
                 if series_count > 0:
-                    metadata = file_loader.get_metadata(filepath, 0)
-                    if metadata:
-                        self.info_label.setText(
-                            f"File contains {series_count} series."
-                        )
-                    else:
-                        self.info_label.setText(
-                            f"File contains {series_count} series. No additional metadata available."
-                        )
-                else:
-                    self.info_label.setText("No series found in this file.")
+                    # metadata = file_loader.get_metadata(filepath, 0)
+
+                    # Estimate file size and set appropriate format radio button
+                    file_type = self.parent.get_file_type(filepath)
+                    if file_type == "ND2":
+                        try:
+                            with nd2.ND2File(filepath) as nd2_file:
+                                dims = dict(nd2_file.sizes)
+                                pixel_size = nd2_file.dtype.itemsize
+                                total_elements = np.prod(
+                                    [dims[dim] for dim in dims]
+                                )
+                                size_GB = (total_elements * pixel_size) / (
+                                    1024**3
+                                )
+
+                                self.info_label.setText(
+                                    f"File contains {series_count} series (size: {size_GB:.2f}GB)"
+                                )
+
+                                # Update format buttons
+                                self.parent.update_format_buttons(size_GB > 4)
+                        except (ValueError, FileNotFoundError) as e:
+                            print(f"Error estimating file size: {e}")
             except FileNotFoundError:
                 self.info_label.setText("File not found.")
             except PermissionError:
@@ -220,6 +246,30 @@ class SeriesDetailWidget(QWidget):
             # Update parent with selected series
             self.parent.set_selected_series(self.current_file, series_index)
 
+            # Automatically set the appropriate format radio button based on file size
+            file_loader = self.parent.get_file_loader(self.current_file)
+            if file_loader:
+                try:
+                    # Estimate file size based on metadata
+                    # metadata = file_loader.get_metadata(
+                    #    self.current_file, series_index
+                    # )
+
+                    # For ND2 files, we can directly check the size
+                    if self.parent.get_file_type(self.current_file) == "ND2":
+                        with nd2.ND2File(self.current_file) as nd2_file:
+                            dims = dict(nd2_file.sizes)
+                            pixel_size = nd2_file.dtype.itemsize
+                            total_elements = np.prod(
+                                [dims[dim] for dim in dims]
+                            )
+                            size_GB = (total_elements * pixel_size) / (1024**3)
+
+                            # Automatically set the appropriate radio button based on size
+                            self.parent.update_format_buttons(size_GB > 4)
+                except (ValueError, FileNotFoundError) as e:
+                    print(f"Error estimating file size: {e}")
+
     def preview_series(self):
         """Preview the selected series in Napari"""
         if self.current_file and self.series_selector.currentIndex() >= 0:
@@ -237,11 +287,25 @@ class SeriesDetailWidget(QWidget):
             file_loader = self.parent.get_file_loader(self.current_file)
 
             try:
+                # First get metadata to understand dimensions
+                metadata = file_loader.get_metadata(
+                    self.current_file, series_index
+                )
+
                 # Load the series
                 image_data = file_loader.load_series(
                     self.current_file, series_index
                 )
 
+                # Reorder dimensions for Napari based on metadata
+                if metadata and "axes" in metadata:
+                    print(f"File has dimension order: {metadata['axes']}")
+                    # Target dimension order for Napari
+                    napari_order = "CTZYX"[: len(image_data.shape)]
+                    image_data = self._reorder_dimensions(
+                        image_data, metadata, napari_order
+                    )
+
                 # Clear existing layers and display the image
                 self.viewer.layers.clear()
                 self.viewer.add_image(
@@ -257,6 +321,67 @@ class SeriesDetailWidget(QWidget):
                     self, "Error", f"Could not load series: {str(e)}"
                 )
 
+    def _reorder_dimensions(self, image_data, metadata, target_order="YXZTC"):
+        """Reorder dimensions based on metadata axes information
+
+        Args:
+            image_data: The numpy or dask array to reorder
+            metadata: Metadata dictionary containing axes information
+            target_order: Target dimension order (e.g., "YXZTC")
+
+        Returns:
+            Reordered array
+        """
+        # Early exit if no metadata or no axes information
+        if not metadata or "axes" not in metadata:
+            print("No axes information in metadata - returning original")
+            return image_data
+
+        # Get source order from metadata
+        source_order = metadata["axes"]
+
+        # Ensure dimensions match
+        ndim = len(image_data.shape)
+        if len(source_order) != ndim:
+            print(
+                f"Dimension mismatch - array has {ndim} dims but axes metadata indicates {len(source_order)}"
+            )
+            return image_data
+
+        # Ensure target order has the same number of dimensions
+        if len(target_order) != ndim:
+            print(
+                f"Target order {target_order} doesn't match array dimensions {ndim}"
+            )
+            return image_data
+
+        # Create reordering index list
+        reorder_indices = []
+        for axis in target_order:
+            if axis in source_order:
+                reorder_indices.append(source_order.index(axis))
+            else:
+                print(f"Axis {axis} not found in source order {source_order}")
+                return image_data
+
+        # Reorder the array using appropriate method
+        try:
+            print(f"Reordering from {source_order} to {target_order}")
+
+            # Check if using Dask array
+            if hasattr(image_data, "dask"):
+                # Use Dask's transpose to preserve lazy computation
+                reordered = image_data.transpose(reorder_indices)
+            else:
+                # Use numpy transpose
+                reordered = np.transpose(image_data, reorder_indices)
+
+            print(f"Reordered shape: {reordered.shape}")
+            return reordered
+        except (ValueError, IndexError) as e:
+            print(f"Error reordering dimensions: {e}")
+            return image_data
+
 
 class FormatLoader:
     """Base class for format loaders"""
@@ -372,7 +497,6 @@ class ND2Loader(FormatLoader):
 
     @staticmethod
     def get_series_count(filepath: str) -> int:
-
         # ND2 files typically have a single series with multiple channels/dimensions
         return 1
 
@@ -381,9 +505,29 @@ class ND2Loader(FormatLoader):
         if series_index != 0:
             raise ValueError("ND2 files only support series index 0")
 
+        # First open the file to check metadata
         with nd2.ND2File(filepath) as nd2_file:
-            # Convert to numpy array
-            return nd2_file.asarray()
+            # Calculate size in GB
+            total_size = np.prod(
+                [nd2_file.sizes[dim] for dim in nd2_file.sizes]
+            )
+            pixel_size = nd2_file.dtype.itemsize
+            size_GB = (total_size * pixel_size) / (1024**3)
+
+            print(f"ND2 file dimensions: {nd2_file.sizes}")
+            print(f"Pixel type: {nd2_file.dtype}, size: {pixel_size} bytes")
+            print(f"Estimated file size: {size_GB:.2f} GB")
+
+        if size_GB > 4:
+            print("Using Dask for large file")
+            # Load as Dask array for large files
+            data = nd2.imread(filepath, dask=True)
+            return data
+        else:
+            print("Using direct loading for smaller file")
+            # Load directly into memory for smaller files
+            data = nd2.imread(filepath)
+            return data
 
     @staticmethod
     def get_metadata(filepath: str, series_index: int) -> Dict:
@@ -391,16 +535,60 @@ class ND2Loader(FormatLoader):
             return {}
 
         with nd2.ND2File(filepath) as nd2_file:
-            return {
-                "axes": "".join(nd2_file.sizes.keys()),
-                "resolution": (
-                    1 / nd2_file.voxel_size().x,
-                    1 / nd2_file.voxel_size().y,
-                ),
+            # Get all dimensions and their sizes
+            dims = dict(nd2_file.sizes)
+
+            # Create a more detailed axes representation
+            axes = "".join(dims.keys())
+
+            print(f"ND2 metadata - dims: {dims}")
+            print(f"ND2 metadata - axes: {axes}")
+
+            # Get spatial dimensions and convert to resolution
+            try:
+                voxel = nd2_file.voxel_size()
+                x_res = 1 / voxel.x if voxel.x > 0 else 1.0
+                y_res = 1 / voxel.y if voxel.y > 0 else 1.0
+                z_spacing = 1 / voxel.z if voxel.z > 0 else 1.0
+
+                print(f"Voxel size: x={voxel.x}, y={voxel.y}, z={voxel.z}")
+            except (ValueError, AttributeError) as e:
+                print(f"Error getting voxel size: {e}")
+                x_res, y_res, z_spacing = 1.0, 1.0, 1.0
+
+            # Create scale information for all dimensions
+            scales = {}
+            if "T" in dims:
+                scales["scale_t"] = 1.0
+            if "Z" in dims:
+                scales["scale_z"] = z_spacing
+            if "C" in dims:
+                scales["scale_c"] = 1.0
+            if "Y" in dims:
+                scales["scale_y"] = y_res
+            if "X" in dims:
+                scales["scale_x"] = x_res
+
+            # Build comprehensive metadata
+            metadata = {
+                "axes": axes,
+                "dimensions": dims,
+                "resolution": (x_res, y_res),
                 "unit": "um",
-                "spacing": 1 / nd2_file.voxel_size().z,
+                "spacing": z_spacing,
+                **scales,  # Add all scale information
             }
 
+            # Add extra metadata for zarr transformations
+            ordered_scales = []
+            for ax in axes:
+                scale_key = f"scale_{ax.lower()}"
+                ordered_scales.append(scales.get(scale_key, 1.0))
+
+            metadata["scales"] = ordered_scales
+
+            return metadata
+
 
 class TIFFSlideLoader(FormatLoader):
     """Loader for whole slide TIFF images (NDPI, etc.)"""
@@ -915,10 +1103,21 @@ class ConversionWorker(QThread):
                 estimated_size_bytes = (
                     np.prod(image_data.shape) * image_data.itemsize
                 )
-                use_zarr = self.use_zarr or (
-                    estimated_size_bytes > 4 * 1024 * 1024 * 1024
-                )
-
+                file_size_GB = estimated_size_bytes / (1024**3)
+
+                # If file is very large (>4GB), force zarr format regardless of setting
+                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",
+                        )
                 # Set up the output path
                 if use_zarr:
                     output_path = os.path.join(
@@ -937,48 +1136,25 @@ class ConversionWorker(QThread):
 
                 try:
                     if use_zarr:
-                        # First try with metadata
-                        try:
-                            if metadata:
-                                self._save_zarr(
-                                    image_data, output_path, metadata
-                                )
-                            else:
-                                self._save_zarr(image_data, output_path)
-                        except (ValueError, FileNotFoundError) as e:
-                            print(
-                                f"Warning: Failed to save with metadata, trying without: {str(e)}"
-                            )
-                            # If that fails, try without metadata
-                            self._save_zarr(image_data, output_path, None)
+                        save_success = self._save_zarr(
+                            image_data, output_path, metadata
+                        )
                     else:
-                        # First try with metadata
-                        try:
-                            if metadata:
-                                self._save_tif(
-                                    image_data, output_path, metadata
-                                )
-                            else:
-                                self._save_tif(image_data, output_path)
-                        except (ValueError, FileNotFoundError) as e:
-                            print(
-                                f"Warning: Failed to save with metadata, trying without: {str(e)}"
-                            )
-                            # If that fails, try without metadata
-                            self._save_tif(image_data, output_path, None)
+                        self._save_tif(image_data, output_path, metadata)
+                        save_success = os.path.exists(output_path)
+
+                    if save_success:
+                        success_count += 1
+                        self.file_done.emit(
+                            filepath, True, f"Saved to {output_path}"
+                        )
+                    else:
+                        error_message = "Failed to save file - unknown error"
+                        self.file_done.emit(filepath, False, error_message)
 
-                    save_success = True
                 except (ValueError, FileNotFoundError) as e:
                     error_message = f"Failed to save file: {str(e)}"
                     print(f"Error in save operation: {error_message}")
-                    save_success = False
-
-                if save_success:
-                    success_count += 1
-                    self.file_done.emit(
-                        filepath, True, f"Saved to {output_path}"
-                    )
-                else:
                     self.file_done.emit(filepath, False, error_message)
 
             except (ValueError, FileNotFoundError) as e:
@@ -995,233 +1171,256 @@ class ConversionWorker(QThread):
     def _save_tif(
         self, image_data: np.ndarray, output_path: str, metadata: dict = None
     ):
-        """Save image data as TIFF with optional metadata"""
-        try:
-            # Basic save without metadata
-            if metadata is None:
-                tifffile.imwrite(output_path, image_data, compression="zstd")
-                return
+        """Enhanced TIF saving with proper dimension handling"""
+        import tifffile
 
-            # Always preserve resolution if it exists
-            resolution = None
-            if "resolution" in metadata:
-                resolution = tuple(float(r) for r in metadata["resolution"])
+        print(f"Saving TIF file: {output_path}")
+        print(f"Image data shape: {image_data.shape}")
 
-            axes = metadata.get("axes", "")
+        if metadata:
+            print(f"Metadata keys: {list(metadata.keys())}")
+            if "axes" in metadata:
+                print(f"Original axes: {metadata['axes']}")
 
-            # Handle different dimension cases appropriately
-            if len(image_data.shape) > 2 and any(ax in axes for ax in "ZC"):
-                # Hyperstack case (3D+ with channels or z-slices)
-                imagej_order = "TZCYX"
+        # Handle Dask arrays
+        if hasattr(image_data, "compute"):
+            print("Computing Dask array before saving")
+            # For large arrays, compute block by block
+            try:
+                # Convert to numpy array in memory
+                image_data = image_data.compute()
+            except (MemoryError, ValueError) as e:
+                print(f"Error computing dask array: {e}")
+                # Alternative: write block by block
+                # This would require custom implementation
+                raise
+
+        # Basic save if no metadata
+        if metadata is None:
+            print("No metadata provided, using basic save")
+            tifffile.imwrite(output_path, image_data, compression="zstd")
+            return
 
-                if axes != imagej_order:
-                    print(
-                        f"Original axes: {axes}, Target order: {imagej_order}"
-                    )
+        # Get image dimensions and axis order
+        ndim = len(image_data.shape)
+        axes = metadata.get("axes", "")
 
-                    # Filter to valid axes
-                    valid_axes = [ax for ax in axes if ax in imagej_order]
-                    if len(valid_axes) < len(axes):
-                        print(f"Dropping axes: {set(axes)-set(imagej_order)}")
-                        source_idx = [
-                            i
-                            for i, ax in enumerate(axes)
-                            if ax in imagej_order
-                        ]
-                        image_data = np.moveaxis(
-                            image_data, source_idx, range(len(valid_axes))
-                        )
-                        axes = "".join(valid_axes)
+        print(f"Number of dimensions: {ndim}")
+        if axes:
+            print(f"Axes from metadata: {axes}")
 
-                    # Add missing dims
-                    for ax in reversed(imagej_order):
-                        if ax not in axes:
-                            print(f"Adding {ax} dimension")
-                            axes = ax + axes
-                            image_data = np.expand_dims(image_data, axis=0)
+        # Handle ImageJ compatibility for dimensions
+        if ndim > 2:
+            # Get target order for ImageJ
+            imagej_order = "TZCYX"
 
-                    # Final reordering
-                    source_idx = [axes.index(ax) for ax in imagej_order]
+            # If axes information is incomplete, try to infer from shape
+            if len(axes) != ndim:
+                print(
+                    f"Warning: Axes length ({len(axes)}) doesn't match dimensions ({ndim})"
+                )
+                # For your specific case with shape (45, 101, 4, 1024, 1024)
+                # Infer TZCYX if shape matches
+                if (
+                    ndim == 5
+                    and image_data.shape[2] <= 10
+                    and image_data.shape[3] > 100
+                    and image_data.shape[4] > 100
+                ):
+                    print("Inferring TZCYX from shape")
+                    axes = "TZCYX"
+
+            if axes and axes != imagej_order:
+                print(f"Reordering: {axes} -> {imagej_order}")
+
+                # Map dimensions from original to target order
+                dim_map = {}
+                for i, ax in enumerate(axes):
+                    if ax in imagej_order:
+                        dim_map[ax] = i
+
+                # Handle missing dimensions
+                for ax in imagej_order:
+                    if ax not in dim_map:
+                        print(f"Adding missing dimension: {ax}")
+                        image_data = np.expand_dims(image_data, axis=0)
+                        dim_map[ax] = image_data.shape[0] - 1
+
+                # Create reordering indices
+                source_idx = [dim_map[ax] for ax in imagej_order]
+                target_idx = list(range(len(imagej_order)))
+
+                print(f"Reordering dimensions: {source_idx} -> {target_idx}")
+
+                # Reorder dimensions
+                try:
                     image_data = np.moveaxis(
-                        image_data, source_idx, range(len(imagej_order))
+                        image_data, source_idx, target_idx
                     )
-                    metadata["axes"] = imagej_order
+                except (ValueError, IndexError) as e:
+                    print(f"Error reordering dimensions: {e}")
+                    # Fall back to simple save without reordering
+                    tifffile.imwrite(
+                        output_path, image_data, compression="zstd"
+                    )
+                    return
+
+                # Update axes information
+                metadata["axes"] = imagej_order
 
+        # Extract resolution information for ImageJ
+        resolution = None
+        if "resolution" in metadata:
+            try:
+                res_x, res_y = metadata["resolution"]
+                resolution = (float(res_x), float(res_y))
+                print(f"Using resolution: {resolution}")
+            except (ValueError, TypeError) as e:
+                print(f"Error processing resolution: {e}")
+
+        # Handle saving with metadata
+        try:
+            if ndim <= 2:
+                # 2D case - simpler saving
+                print("Saving as 2D image")
                 tifffile.imwrite(
                     output_path,
                     image_data,
-                    metadata=metadata,
                     resolution=resolution,
-                    imagej=True,
                     compression="zstd",
                 )
             else:
-                # 2D case - save without hyperstack metadata but keep resolution
-                save_metadata = (
-                    {"resolution": metadata["resolution"]}
-                    if "resolution" in metadata
-                    else None
-                )
+                # Hyperstack case
+                print("Saving as hyperstack with ImageJ metadata")
+
+                # Create clean metadata dict with only needed keys
+                imagej_metadata = {}
+                if "unit" in metadata:
+                    imagej_metadata["unit"] = metadata["unit"]
+                if "spacing" in metadata:
+                    imagej_metadata["spacing"] = float(metadata["spacing"])
+
                 tifffile.imwrite(
                     output_path,
                     image_data,
-                    metadata=save_metadata,
+                    imagej=True,
                     resolution=resolution,
-                    imagej=False,
+                    metadata=imagej_metadata,
                     compression="zstd",
                 )
 
+            print(f"Successfully saved TIF file: {output_path}")
         except (ValueError, FileNotFoundError) as e:
-            print(f"Error: {str(e)}")
+            print(f"Error saving TIF file: {e}")
+            # Try simple save as fallback
             tifffile.imwrite(output_path, image_data)
 
     def _save_zarr(
         self, image_data: np.ndarray, output_path: str, metadata: dict = None
     ):
-        """Save image data as OME-Zarr format with optional metadata."""
-        try:
-            # Determine optimal chunk size
-            target_chunk_size = 1024 * 1024  # 1MB
-            item_size = image_data.itemsize
-            chunks = self._calculate_chunks(
-                image_data.shape, target_chunk_size, item_size
-            )
+        """Enhanced ZARR saving with proper metadata storage and specific exceptions"""
+        print(f"Saving ZARR file: {output_path}")
+        print(f"Image data shape: {image_data.shape}")
 
-            # Determine appropriate axes based on dimensions
-            ndim = len(image_data.shape)
-            default_axes = "TCZYX"
-            axes = (
-                default_axes[-ndim:]
-                if ndim <= 5
-                else "".join([f"D{i}" for i in range(ndim)])
-            )
+        metadata = metadata or {}
+        print(
+            f"Metadata keys: {list(metadata.keys()) if metadata else 'No metadata'}"
+        )
 
-            # Create the zarr store
-            store = zarr.DirectoryStore(output_path)
+        # Handle overwriting by deleting the directory if it exists
+        if os.path.exists(output_path):
+            print(f"Deleting existing Zarr directory: {output_path}")
+            shutil.rmtree(output_path)
 
-            # Set up transformations if possible
-            coordinate_transformations = None
-            if metadata:
-                try:
-                    # Extract scale information if present
-                    scales = []
-                    for _i, ax in enumerate(axes):
-                        scale = 1.0  # Default scale
-
-                        # Try to find scale for this axis
-                        scale_key = f"scale_{ax.lower()}"
-                        if scale_key in metadata:
-                            try:
-                                scale_value = float(metadata[scale_key])
-                                if scale_value > 0:  # Only use valid values
-                                    scale = scale_value
-                            except (ValueError, TypeError):
-                                pass
-
-                        scales.append(scale)
-
-                    # Only create transformations if we have non-default scales
-                    if any(s != 1.0 for s in scales):
-                        coordinate_transformations = [
-                            {"type": "scale", "scale": scales}
-                        ]
-                except (ValueError, FileNotFoundError) as e:
-                    print(
-                        f"Warning: Could not process coordinate transformations: {str(e)}"
-                    )
-                    coordinate_transformations = None
-
-            # Write the image data using the OME-Zarr writer
-            write_options = {
-                "image": image_data,
-                "group": store,
-                "axes": axes,
-                "chunks": chunks,
-                "compression": "zstd",
-                "compression_opts": {"level": 3},
-            }
+        # Explicitly create a DirectoryStore
+        store = parse_url(output_path, mode="w").store
 
-            # Add transformations if available
-            if coordinate_transformations:
-                write_options["coordinate_transformations"] = (
-                    coordinate_transformations
-                )
+        ndim = len(image_data.shape)
 
-            write_image(**write_options)
-            print(f"Saved OME-Zarr image data: {output_path}")
+        axes = metadata.get("axes").lower() if metadata else None
 
-            # Try to add metadata
-            if metadata:
-                try:
-                    # Access the root group
-                    root = zarr.group(store)
-
-                    # Add OMERO metadata
-                    if "omero" not in root:
-                        root.create_group("omero")
-                    omero_metadata = root["omero"]
-                    omero_metadata.attrs["version"] = "0.4"
-
-                    # Add original metadata in a separate group
-                    if "original_metadata" not in root:
-                        metadata_group = root.create_group("original_metadata")
+        # Standardize axes order to 'ctzyx' if possible, regardless of Z presence
+        target_axes = "tczyx"
+        if axes != target_axes[:ndim]:
+            print(f"Reordering axes from {axes} to {target_axes[:ndim]}")
+            try:
+                # Create a mapping from original axes to target axes
+                axes_map = {ax: i for i, ax in enumerate(axes)}
+                reorder_list = []
+                for _i, target_ax in enumerate(target_axes[:ndim]):
+                    if target_ax in axes_map:
+                        reorder_list.append(axes_map[target_ax])
                     else:
-                        metadata_group = root["original_metadata"]
-
-                    # Add metadata as attributes, safely converting types
-                    for key, value in metadata.items():
-                        try:
-                            # Try to store directly if it's a simple type
-                            if isinstance(
-                                value, (str, int, float, bool, type(None))
-                            ):
-                                metadata_group.attrs[key] = value
-                            else:
-                                # Otherwise convert to string
-                                metadata_group.attrs[key] = str(value)
-                        except (ValueError, TypeError) as e:
-                            print(
-                                f"Warning: Could not store metadata key '{key}': {str(e)}"
-                            )
+                        print(f"Axis {target_ax} not found in original axes")
+                        reorder_list.append(None)
 
-                    print(f"Added metadata to OME-Zarr file: {output_path}")
-                except (ValueError, FileNotFoundError) as e:
-                    print(f"Warning: Could not add metadata to Zarr: {str(e)}")
+                # Filter out None values (missing axes)
+                reorder_list = [i for i in reorder_list if i is not None]
 
-            return output_path
-        except (ValueError, FileNotFoundError) as e:
-            print(f"Error in _save_zarr: {str(e)}")
-            # For zarr, we don't have a simpler fallback method, so re-raise
-            raise
+                if len(reorder_list) != len(axes):
+                    raise ValueError(
+                        "Reordering failed: Mismatch between original and reordered dimensions."
+                    )
+                image_data = np.moveaxis(
+                    image_data, range(len(axes)), reorder_list
+                )
+                axes = "".join(
+                    [axes[i] for i in reorder_list]
+                )  # Update axes to reflect new order
+                print(f"New axes order after reordering: {axes}")
+            except (ValueError, IndexError) as e:
+                print(f"Error during reordering: {e}")
+                raise
+
+        # Convert to Dask array
+        if not hasattr(image_data, "dask"):
+            print("Converting to dask array with auto chunks...")
+            image_data = da.from_array(image_data, chunks="auto")
+        else:
+            print("Using existing dask array")
 
-    def _calculate_chunks(self, shape, target_size, item_size):
-        """Calculate appropriate chunk sizes for zarr storage"""
+        # Write the image data as OME-Zarr
         try:
-            total_elements = np.prod(shape)
-            elements_per_chunk = target_size // item_size
-
-            chunk_shape = list(shape)
-            for i in reversed(range(len(chunk_shape))):
-                # Guard against division by zero
-                if total_elements > 0 and chunk_shape[i] > 0:
-                    chunk_shape[i] = max(
-                        1,
-                        int(
-                            elements_per_chunk
-                            / (total_elements / chunk_shape[i])
-                        ),
-                    )
-                    break
+            print("Writing image data using ome_zarr.writer.write_image...")
+            with ProgressBar():
+                root = zarr.group(store=store)
+                write_image(
+                    image_data,
+                    group=root,
+                    axes=axes,
+                    scaler=None,
+                    storage_options={"compression": "zstd"},
+                )
 
-            # Ensure chunks aren't larger than dimensions
-            for i in range(len(chunk_shape)):
-                chunk_shape[i] = min(chunk_shape[i], shape[i])
+            # Add basic OME-Zarr metadata
+            root = zarr.open(store)
+            root.attrs["multiscales"] = [
+                {
+                    "version": "0.4",
+                    "datasets": [{"path": "0"}],
+                    "axes": [
+                        {
+                            "name": ax,
+                            "type": (
+                                "space"
+                                if ax in "xyz"
+                                else "time" if ax == "t" else "channel"
+                            ),
+                        }
+                        for ax in axes
+                    ],
+                }
+            ]
+
+            print("OME-Zarr file saved successfully.")
+            return True
 
-            return tuple(chunk_shape)
         except (ValueError, FileNotFoundError) as e:
-            print(f"Warning: Error calculating chunks: {str(e)}")
-            # Return a default chunk size that's safe
-            return tuple(min(512, d) for d in shape)
+            print(f"Error during Zarr writing: {e}")
+            import traceback
+
+            traceback.print_exc()
+            return False
 
 
 class MicroscopyImageConverterWidget(QWidget):
@@ -1250,6 +1449,9 @@ class MicroscopyImageConverterWidget(QWidget):
         self.scan_worker = None
         self.conversion_worker = None
 
+        # Flag to prevent recursive radio button updates
+        self.updating_format_buttons = False
+
         # Create layout
         main_layout = QVBoxLayout()
         self.setLayout(main_layout)
@@ -1311,16 +1513,8 @@ class MicroscopyImageConverterWidget(QWidget):
         self.zarr_radio = QCheckBox("ZARR (> 4GB)")
 
         # Make checkboxes mutually exclusive like radio buttons
-        self.tif_radio.toggled.connect(
-            lambda checked: (
-                self.zarr_radio.setChecked(not checked) if checked else None
-            )
-        )
-        self.zarr_radio.toggled.connect(
-            lambda checked: (
-                self.tif_radio.setChecked(not checked) if checked else None
-            )
-        )
+        self.tif_radio.toggled.connect(self.handle_format_toggle)
+        self.zarr_radio.toggled.connect(self.handle_format_toggle)
 
         format_layout.addWidget(format_label)
         format_layout.addWidget(self.tif_radio)
@@ -1679,6 +1873,44 @@ class MicroscopyImageConverterWidget(QWidget):
         else:
             self.status_label.setText("No files were converted")
 
+    def update_format_buttons(self, use_zarr=False):
+        """Update format radio buttons based on file size
+
+        Args:
+            use_zarr: True if file size > 4GB, otherwise False
+        """
+        if self.updating_format_buttons:
+            return
+
+        self.updating_format_buttons = True
+        try:
+            if use_zarr:
+                self.zarr_radio.setChecked(True)
+                self.tif_radio.setChecked(False)
+                print("Auto-selected ZARR format for large file (>4GB)")
+            else:
+                self.tif_radio.setChecked(True)
+                self.zarr_radio.setChecked(False)
+                print("Auto-selected TIF format for smaller file (<4GB)")
+        finally:
+            self.updating_format_buttons = False
+
+    def handle_format_toggle(self, checked):
+        """Handle format radio button toggle"""
+        if self.updating_format_buttons:
+            return
+
+        self.updating_format_buttons = True
+        try:
+            # Make checkboxes mutually exclusive like radio buttons
+            sender = self.sender()
+            if sender == self.tif_radio and checked:
+                self.zarr_radio.setChecked(False)
+            elif sender == self.zarr_radio and checked:
+                self.tif_radio.setChecked(False)
+        finally:
+            self.updating_format_buttons = False
+
 
 # Create a MagicGUI widget that creates and returns the converter widget
 @magicgui(