[feat] Ensure pyramidal tiff on import

tmoerkerken · tmoerkerken · commit 7bef02b4dd8d · 2026-03-18T09:10:27.000+01:00
diff --git a/src/odemis/dataio/test/tiff_test.py b/src/odemis/dataio/test/tiff_test.py
@@ -25,6 +25,7 @@
 import logging
 import os
 import re
+import tempfile
 import time
 import unittest
 import xml.etree.ElementTree as ET
@@ -47,6 +48,52 @@
 logging.getLogger().setLevel(logging.DEBUG)
 
 FILENAME = "test" + tiff.EXTENSIONS[0]
+
+
+class TestTiffPyramidalIO(unittest.TestCase):
+
+    def setUp(self) -> None:
+        self.temp_dir = tempfile.mkdtemp()
+
+    def tearDown(self) -> None:
+        try:
+            for filename in os.listdir(self.temp_dir):
+                file_path = os.path.join(self.temp_dir, filename)
+                if os.path.isfile(file_path):
+                    os.remove(file_path)
+            os.rmdir(self.temp_dir)
+        except Exception:
+            pass
+
+    def _create_test_tiff(self, filename: str, pyramid: bool = False) -> str:
+        array = numpy.random.randint(0, 255, (256, 256), dtype=numpy.uint8)
+        data = model.DataArray(array)
+        full_path = os.path.join(self.temp_dir, filename)
+        tiff.export(full_path, data, pyramid=pyramid, imagej=True)
+        return full_path
+
+    def test_is_pyramidal_tiff(self) -> None:
+        pyramidal_file = self._create_test_tiff("pyramidal.tif", pyramid=True)
+        self.assertTrue(tiff.is_pyramidal(pyramidal_file))
+
+    def test_is_pyramidal_non_pyramidal_tiff(self) -> None:
+        non_pyramidal_file = self._create_test_tiff("non_pyramidal.tif", pyramid=False)
+        self.assertFalse(tiff.is_pyramidal(non_pyramidal_file))
+
+    def test_is_pyramidal_invalid_file(self) -> None:
+        with self.assertRaises(IOError):
+            tiff.is_pyramidal("/nonexistent/file.tif")
+
+    def test_convert_to_pyramidal_tiff(self) -> None:
+        source_file = self._create_test_tiff("source.tif", pyramid=False)
+        dest_file = os.path.join(self.temp_dir, "converted.tif")
+
+        tiff.convert_to_pyramidal(source_file, dest_file, compressed=True)
+
+        self.assertTrue(os.path.exists(dest_file))
+        self.assertTrue(tiff.is_pyramidal(dest_file))
+
+
 class TestTiffIO(unittest.TestCase):
 
     def tearDown(self):
diff --git a/src/odemis/dataio/tiff.py b/src/odemis/dataio/tiff.py
@@ -2401,6 +2401,42 @@ def read_data(filename):
     return [acd.content[n].getData() for n in range(len(acd.content))]
 
 
+def is_pyramidal(filename: str) -> bool:
+    """
+    Check whether a TIFF file has SubIFD pyramid levels.
+
+    :param filename: Path to TIFF file
+    :return: True when TIFFTAG_SUBIFD contains one or more entries
+    :raises IOError: If the file cannot be opened as TIFF
+    """
+    try:
+        tiff_file = TIFF.open(filename, mode="r")
+        try:
+            sub_ifds = tiff_file.GetField(T.TIFFTAG_SUBIFD)
+            return sub_ifds is not None and len(sub_ifds) > 0
+        finally:
+            tiff_file.close()
+    except Exception as exc:
+        raise IOError("Failed to inspect TIFF pyramid status for %s: %s" % (filename, exc))
+
+
+def convert_to_pyramidal(src_filename: str, dst_filename: str, compressed: bool = True) -> None:
+    """
+    Convert TIFF content into a pyramidal TIFF.
+
+    :param src_filename: Source TIFF file path
+    :param dst_filename: Destination TIFF file path
+    :param compressed: Whether to write with TIFF compression
+    :raises IOError: If conversion fails
+    """
+    try:
+        data = read_data(src_filename)
+        export(dst_filename, data, compressed=compressed, pyramid=True)
+    except Exception as exc:
+        raise IOError("Failed to convert TIFF %s to pyramidal %s: %s" %
+                      (src_filename, dst_filename, exc))
+
+
 def read_thumbnail(filename):
     """
     Read the thumbnail data of a given TIFF file.
diff --git a/src/odemis/gui/cont/tabs/analysis_tab.py b/src/odemis/gui/cont/tabs/analysis_tab.py
@@ -60,6 +60,10 @@
     TOOL_NONE
 from odemis.gui.util import call_in_wx_main
 from odemis.util.dataio import data_to_static_streams, open_acquisition, open_files_and_stitch
+from odemis.util.tiff_convert import (
+    ensure_pyramidal_tiff_for_file_gui,
+    ensure_pyramidal_tiff_for_tileset_gui,
+)
 
 
 class AnalysisTab(Tab):
@@ -319,10 +323,14 @@ def _on_add_tileset(self):
         self.select_acq_file(extend=True, tileset=True)
 
     def load_tileset(self, filenames, extend=False):
+        # Convert all files to pyramidal if they're TIFFs
+        filenames = ensure_pyramidal_tiff_for_tileset_gui(filenames, self.panel, self.tab_data_model.main)
         data = open_files_and_stitch(filenames) # TODO: allow user defined registration / weave methods
         self.display_new_data(filenames[0], data, extend=extend)
 
     def load_data(self, filename, fmt=None, extend=False):
+        # Convert to pyramidal if it's a TIFF file
+        filename = ensure_pyramidal_tiff_for_file_gui(filename, self.panel, self.tab_data_model.main)
         data = open_acquisition(filename, fmt)
         self.display_new_data(filename, data, extend=extend)
 
diff --git a/src/odemis/gui/cont/tabs/correlation_tab.py b/src/odemis/gui/cont/tabs/correlation_tab.py
@@ -45,6 +45,10 @@
 from odemis.gui.util import call_in_wx_main
 from odemis.gui.cont.tabs.tab import Tab
 from odemis.util.dataio import data_to_static_streams, open_acquisition, open_files_and_stitch
+from odemis.util.tiff_convert import (
+    ensure_pyramidal_tiff_for_file_gui,
+    ensure_pyramidal_tiff_for_tileset_gui,
+)
 
 
 class CorrelationTab(Tab):
@@ -167,10 +171,14 @@ def _on_add_tileset(self) -> None:
         self.select_acq_file(extend=True, tileset=True)
 
     def load_tileset(self, filenames: List[str], extend: bool = False) -> None:
+        # Convert all files to pyramidal if they're TIFFs
+        filenames = ensure_pyramidal_tiff_for_tileset_gui(filenames, self.panel, self.main_data)
         data = open_files_and_stitch(filenames) # TODO: allow user defined registration / weave methods
         self.load_streams(data)
 
     def load_data(self, filename: str, fmt: str = None, extend: bool = False) -> None:
+        # Convert to pyramidal if it's a TIFF file
+        filename = ensure_pyramidal_tiff_for_file_gui(filename, self.panel, self.main_data)
         data = open_acquisition(filename, fmt)
         self.load_streams(data)
 
diff --git a/src/odemis/util/test/tiff_convert_test.py b/src/odemis/util/test/tiff_convert_test.py
@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+"""
+Created on 17 Mar 2026
+
+@author: Tim Moerkerken
+
+Copyright © 2014-2026 Tim Moerkerken, Delmic
+
+This file is part of Odemis.
+
+Odemis is free software: you can redistribute it and/or modify it under the terms
+of the GNU General Public License version 2 as published by the Free Software
+Foundation.
+
+Odemis is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+Odemis. If not, see http://www.gnu.org/licenses/.
+"""
+
+import os
+import tempfile
+import unittest
+import numpy
+
+from odemis import model
+from odemis.dataio import tiff
+from odemis.util.tiff_convert import (
+    get_conversion_output_path,
+    ensure_pyramidal_tiff,
+)
+
+
+class TestTiffConversion(unittest.TestCase):
+
+    def setUp(self) -> None:
+        """Set up test fixtures."""
+        self.temp_dir = tempfile.mkdtemp()
+
+    def tearDown(self) -> None:
+        """Clean up temporary files."""
+        # Remove all temporary files
+        try:
+            for filename in os.listdir(self.temp_dir):
+                file_path = os.path.join(self.temp_dir, filename)
+                if os.path.isfile(file_path):
+                    os.remove(file_path)
+            os.rmdir(self.temp_dir)
+        except Exception:
+            pass
+
+    def _create_test_tiff(self, filename: str, pyramid: bool = False) -> str:
+        """
+        Create a test TIFF file.
+
+        :param filename: Output filename
+        :param pyramid: If True, create a pyramidal TIFF
+        :return: Full path to created file
+        """
+        # Create simple test image
+        array = numpy.random.randint(0, 255, (256, 256), dtype=numpy.uint8)
+        data = model.DataArray(array)
+
+        full_path = os.path.join(self.temp_dir, filename)
+        tiff.export(full_path, data, pyramid=pyramid, imagej=True)  # Use ImageJ format to avoid OME issues
+        return full_path
+
+    def test_get_conversion_output_path_standalone(self) -> None:
+        """Test output path generation in standalone mode."""
+        source_file = os.path.join(self.temp_dir, "original.tif")
+        output = get_conversion_output_path(source_file, standalone_mode=True)
+
+        # Should be in same directory with visible prefix
+        self.assertEqual(os.path.dirname(output), self.temp_dir)
+        self.assertTrue(os.path.basename(output).startswith("converted_"))
+        self.assertTrue(os.path.basename(output).endswith(".tif"))
+
+    def test_get_conversion_output_path_normal_mode(self) -> None:
+        """Test output path generation in normal mode."""
+        source_file = "/some/path/original.tif"
+        project_folder = "/project/folder"
+        output = get_conversion_output_path(source_file, standalone_mode=False, project_folder=project_folder)
+
+        # Should be in project folder
+        self.assertEqual(os.path.dirname(output), project_folder)
+        self.assertTrue(os.path.basename(output).startswith("converted_"))
+
+    def test_get_conversion_output_path_normal_mode_no_project(self) -> None:
+        """Test that ValueError is raised when project_folder is missing in normal mode."""
+        source_file = "/some/path/original.tif"
+        with self.assertRaises(ValueError):
+            get_conversion_output_path(source_file, standalone_mode=False, project_folder=None)
+
+    def test_ensure_pyramidal_tiff_already_pyramidal(self) -> None:
+        """Test ensure_pyramidal_tiff with already pyramidal file."""
+        pyramidal_file = self._create_test_tiff("already_pyramidal.tif", pyramid=True)
+
+        # Call ensure_pyramidal_tiff
+        result = ensure_pyramidal_tiff(pyramidal_file, standalone_mode=True)
+
+        # Should return the same file without conversion
+        self.assertEqual(result, pyramidal_file)
+
+    def test_ensure_pyramidal_tiff_non_tiff_file(self) -> None:
+        """Test ensure_pyramidal_tiff with non-TIFF file."""
+        # Create a non-TIFF file
+        non_tiff_file = os.path.join(self.temp_dir, "test.txt")
+        with open(non_tiff_file, 'w') as f:
+            f.write("test content")
+
+        # Non-TIFF should return as-is (in ensure_pyramidal_tiff before conversion attempt)
+        result = ensure_pyramidal_tiff(non_tiff_file, standalone_mode=True)
+        self.assertEqual(result, non_tiff_file)
+
+    def test_ensure_pyramidal_tiff_nonexistent_file(self) -> None:
+        """Test ensure_pyramidal_tiff with non-existent file."""
+        with self.assertRaises(IOError):
+            ensure_pyramidal_tiff("/nonexistent/file.tif", standalone_mode=True)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/src/odemis/util/tiff_convert.py b/src/odemis/util/tiff_convert.py
