PyHoloscope 1.0.0__tar.gz

pyholoscope-1.0.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: PyHoloscope
+Version: 1.0.0
+Summary: Python package for holographic microscopy.
+Author-email: Michael Hughes <m.r.hughes@kent.ac.uk>
+Project-URL: Homepage, https://github.com/MikeHughesKent/PyHoloscope/
+Keywords: holographic,microscopy,microscopy,holography,inline holography,off-axis holography
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: matplotlib>=3.3.4
+Requires-Dist: numba>=0.55.1
+Requires-Dist: numpy>=1.22
+Requires-Dist: opencv_python>=4.5
+Requires-Dist: Pillow>=9
+Requires-Dist: scipy>=1.7
+
+![Documentation Status](https://app.readthedocs.org/projects/pyholoscope/badge/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+![PyHoloscope Logo](/res/pyholoscope_logo_.png)
+# PyHololoscope: Fast Holographic Microscopy for Python
+
+PyHoloscope is a Python package for holographic microscopy, providing perfomant reconstruction of inline and off-axis holograms.
+
+It is currently pre-release, aiming for release 1.0.0 before end of 2025.
+
+PyHoloscope is designed to be:
+* Fast (for Python) - optmised for CPU using Numpy, Scipy and Numba, with GPU support via CuPy
+* Easy to Use - a simple object-oriented API gives high performance without low-level tweaks
+* Suitable for Live Imaging - can be used as the back-end of holographic microscopy GUIs as well as for offline processing
+
+Full documentation is on [Read the docs](https://pyholoscope.readthedocs.io/en/latest/index.html). 
+
+Also see the examples in the [examples folder](https://github.com/MikeHughesKent/PyHoloscope/tree/main/examples).
+
+Contributions to the package (new features, tests or documentation) as very welcome, please see the roadmap below and post in the discussion if you are working on something, or [get in touch](mailto:m.r.hughes@kent.ac.uk).
+
+Development is co-ordinated by [Mike Hughes](https://research.kent.ac.uk/applied-optics/hughes/)' lab in the 
+[Applied Optics Group](https://research.kent.ac.uk/applied-optics), Physics & Astronomy, University of Kent. 
+
+If you are interested in academic applications we are happy to help, post in the discussion. If you would like help using PyHoloscope for commercial purposes, consultancy is available, please contact [Mike Hughes](mailto:m.r.hughes@kent.ac.uk) in the first instance.
+
+## Features
+
+### General
+* Object-oriented interface
+* Choice of single or double precision
+* Support for CUDA compatible GPUs
+* Optional use of Numba JIT compiler
+* Supports non-square holograms
+
+### Off Axis Holography
+* Quantitatave phase and amplitude recovery from off-axis hologram
+* Auto detect off-axis modulation frequency
+* Predict tilt angle from modulation frequency
+
+### Numerical Refocusing (Inline and Off-axis Holgoraphy)
+* Refocus holograms or complex fields using the angular spectrum method 
+* Choice of cosine windows to reduce edge effects 
+* Generate stack of images at different refocus depths
+* Apply focus metrics (Brenner, Sobel, Peak Intensity, DarkFocus, SobelVariance)
+* Auto focus whole image or ROI by optimising focus metric, through fast bounded search and (optionally) initial coarse search to narrow search range.
+* Generate LUT of propagators for faster auto-focus or repeated generation of focus stacks.
+
+### Phase Visualation
+* Remove background phase 
+* Remove phase tilt
+* Show phase relative to region of interest 
+* Generate phase contrast image
+* Generate synthetic DIC image
+
+## Roadmap of Planned Developments (help welcome!)
+
+- [ ] Phase recovery for inline holography
+- [ ] Improved optimisation for speed/multiple back-ends
+- [ ] Support phase-shifting holography
+- [ ] Support coded aperture/multi-depth phase recovery
+- [ ] Support forward scattering and inference 
+- [ ] Support particle tracking 
+- [ ] Deep learning for focusing
+- [ ] Targeted support for edge computing (e.g. Raspberry Pi)
+
+## Requirements
+* Numpy
+* Scipy
+* PIL
+* OpenCV
+* Scikit-Image
+* Matplotlib
+* Numba (optional, for JIT acceleration)
+* CuPy (optional, for GPU)

pyholoscope-1.0.0/README.md

@@ -0,0 +1,75 @@
+![Documentation Status](https://app.readthedocs.org/projects/pyholoscope/badge/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+![PyHoloscope Logo](/res/pyholoscope_logo_.png)
+# PyHololoscope: Fast Holographic Microscopy for Python
+
+PyHoloscope is a Python package for holographic microscopy, providing perfomant reconstruction of inline and off-axis holograms.
+
+It is currently pre-release, aiming for release 1.0.0 before end of 2025.
+
+PyHoloscope is designed to be:
+* Fast (for Python) - optmised for CPU using Numpy, Scipy and Numba, with GPU support via CuPy
+* Easy to Use - a simple object-oriented API gives high performance without low-level tweaks
+* Suitable for Live Imaging - can be used as the back-end of holographic microscopy GUIs as well as for offline processing
+
+Full documentation is on [Read the docs](https://pyholoscope.readthedocs.io/en/latest/index.html). 
+
+Also see the examples in the [examples folder](https://github.com/MikeHughesKent/PyHoloscope/tree/main/examples).
+
+Contributions to the package (new features, tests or documentation) as very welcome, please see the roadmap below and post in the discussion if you are working on something, or [get in touch](mailto:m.r.hughes@kent.ac.uk).
+
+Development is co-ordinated by [Mike Hughes](https://research.kent.ac.uk/applied-optics/hughes/)' lab in the 
+[Applied Optics Group](https://research.kent.ac.uk/applied-optics), Physics & Astronomy, University of Kent. 
+
+If you are interested in academic applications we are happy to help, post in the discussion. If you would like help using PyHoloscope for commercial purposes, consultancy is available, please contact [Mike Hughes](mailto:m.r.hughes@kent.ac.uk) in the first instance.
+
+## Features
+
+### General
+* Object-oriented interface
+* Choice of single or double precision
+* Support for CUDA compatible GPUs
+* Optional use of Numba JIT compiler
+* Supports non-square holograms
+
+### Off Axis Holography
+* Quantitatave phase and amplitude recovery from off-axis hologram
+* Auto detect off-axis modulation frequency
+* Predict tilt angle from modulation frequency
+
+### Numerical Refocusing (Inline and Off-axis Holgoraphy)
+* Refocus holograms or complex fields using the angular spectrum method 
+* Choice of cosine windows to reduce edge effects 
+* Generate stack of images at different refocus depths
+* Apply focus metrics (Brenner, Sobel, Peak Intensity, DarkFocus, SobelVariance)
+* Auto focus whole image or ROI by optimising focus metric, through fast bounded search and (optionally) initial coarse search to narrow search range.
+* Generate LUT of propagators for faster auto-focus or repeated generation of focus stacks.
+
+### Phase Visualation
+* Remove background phase 
+* Remove phase tilt
+* Show phase relative to region of interest 
+* Generate phase contrast image
+* Generate synthetic DIC image
+
+## Roadmap of Planned Developments (help welcome!)
+
+- [ ] Phase recovery for inline holography
+- [ ] Improved optimisation for speed/multiple back-ends
+- [ ] Support phase-shifting holography
+- [ ] Support coded aperture/multi-depth phase recovery
+- [ ] Support forward scattering and inference 
+- [ ] Support particle tracking 
+- [ ] Deep learning for focusing
+- [ ] Targeted support for edge computing (e.g. Raspberry Pi)
+
+## Requirements
+* Numpy
+* Scipy
+* PIL
+* OpenCV
+* Scikit-Image
+* Matplotlib
+* Numba (optional, for JIT acceleration)
+* CuPy (optional, for GPU)

pyholoscope-1.0.0/pyproject.toml

@@ -0,0 +1,32 @@
+# pyproject.toml
+
+[build-system]
+requires      = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "PyHoloscope"
+version = "1.0.0"
+description = "Python package for holographic microscopy."
+readme = "README.md"
+authors = [{ name = "Michael Hughes", email = "m.r.hughes@kent.ac.uk" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+]
+keywords = ["holographic", "microscopy", "microscopy", "holography", "inline holography", "off-axis holography"]
+dependencies = [
+    "matplotlib>=3.3.4",
+    "numba>=0.55.1",
+    "numpy >= 1.22",
+    "opencv_python>=4.5",
+    "Pillow>=9",
+    "scipy>=1.7"   
+]
+requires-python = ">=3.8"
+
+[project.urls]
+Homepage = "https://github.com/MikeHughesKent/PyHoloscope/"
+

pyholoscope-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyholoscope-1.0.0/src/PyHoloscope.egg-info/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: PyHoloscope
+Version: 1.0.0
+Summary: Python package for holographic microscopy.
+Author-email: Michael Hughes <m.r.hughes@kent.ac.uk>
+Project-URL: Homepage, https://github.com/MikeHughesKent/PyHoloscope/
+Keywords: holographic,microscopy,microscopy,holography,inline holography,off-axis holography
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: matplotlib>=3.3.4
+Requires-Dist: numba>=0.55.1
+Requires-Dist: numpy>=1.22
+Requires-Dist: opencv_python>=4.5
+Requires-Dist: Pillow>=9
+Requires-Dist: scipy>=1.7
+
+![Documentation Status](https://app.readthedocs.org/projects/pyholoscope/badge/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+![PyHoloscope Logo](/res/pyholoscope_logo_.png)
+# PyHololoscope: Fast Holographic Microscopy for Python
+
+PyHoloscope is a Python package for holographic microscopy, providing perfomant reconstruction of inline and off-axis holograms.
+
+It is currently pre-release, aiming for release 1.0.0 before end of 2025.
+
+PyHoloscope is designed to be:
+* Fast (for Python) - optmised for CPU using Numpy, Scipy and Numba, with GPU support via CuPy
+* Easy to Use - a simple object-oriented API gives high performance without low-level tweaks
+* Suitable for Live Imaging - can be used as the back-end of holographic microscopy GUIs as well as for offline processing
+
+Full documentation is on [Read the docs](https://pyholoscope.readthedocs.io/en/latest/index.html). 
+
+Also see the examples in the [examples folder](https://github.com/MikeHughesKent/PyHoloscope/tree/main/examples).
+
+Contributions to the package (new features, tests or documentation) as very welcome, please see the roadmap below and post in the discussion if you are working on something, or [get in touch](mailto:m.r.hughes@kent.ac.uk).
+
+Development is co-ordinated by [Mike Hughes](https://research.kent.ac.uk/applied-optics/hughes/)' lab in the 
+[Applied Optics Group](https://research.kent.ac.uk/applied-optics), Physics & Astronomy, University of Kent. 
+
+If you are interested in academic applications we are happy to help, post in the discussion. If you would like help using PyHoloscope for commercial purposes, consultancy is available, please contact [Mike Hughes](mailto:m.r.hughes@kent.ac.uk) in the first instance.
+
+## Features
+
+### General
+* Object-oriented interface
+* Choice of single or double precision
+* Support for CUDA compatible GPUs
+* Optional use of Numba JIT compiler
+* Supports non-square holograms
+
+### Off Axis Holography
+* Quantitatave phase and amplitude recovery from off-axis hologram
+* Auto detect off-axis modulation frequency
+* Predict tilt angle from modulation frequency
+
+### Numerical Refocusing (Inline and Off-axis Holgoraphy)
+* Refocus holograms or complex fields using the angular spectrum method 
+* Choice of cosine windows to reduce edge effects 
+* Generate stack of images at different refocus depths
+* Apply focus metrics (Brenner, Sobel, Peak Intensity, DarkFocus, SobelVariance)
+* Auto focus whole image or ROI by optimising focus metric, through fast bounded search and (optionally) initial coarse search to narrow search range.
+* Generate LUT of propagators for faster auto-focus or repeated generation of focus stacks.
+
+### Phase Visualation
+* Remove background phase 
+* Remove phase tilt
+* Show phase relative to region of interest 
+* Generate phase contrast image
+* Generate synthetic DIC image
+
+## Roadmap of Planned Developments (help welcome!)
+
+- [ ] Phase recovery for inline holography
+- [ ] Improved optimisation for speed/multiple back-ends
+- [ ] Support phase-shifting holography
+- [ ] Support coded aperture/multi-depth phase recovery
+- [ ] Support forward scattering and inference 
+- [ ] Support particle tracking 
+- [ ] Deep learning for focusing
+- [ ] Targeted support for edge computing (e.g. Raspberry Pi)
+
+## Requirements
+* Numpy
+* Scipy
+* PIL
+* OpenCV
+* Scikit-Image
+* Matplotlib
+* Numba (optional, for JIT acceleration)
+* CuPy (optional, for GPU)

pyholoscope-1.0.0/src/PyHoloscope.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+README.md
+pyproject.toml
+src/PyHoloscope.egg-info/PKG-INFO
+src/PyHoloscope.egg-info/SOURCES.txt
+src/PyHoloscope.egg-info/dependency_links.txt
+src/PyHoloscope.egg-info/requires.txt
+src/PyHoloscope.egg-info/top_level.txt
+src/pyholoscope/__init__.py
+src/pyholoscope/focus_shift.py
+src/pyholoscope/focus_stack.py
+src/pyholoscope/focusing.py
+src/pyholoscope/focusing_numba.py
+src/pyholoscope/general.py
+src/pyholoscope/holo_class.py
+src/pyholoscope/off_axis.py
+src/pyholoscope/phase_proc.py
+src/pyholoscope/prop_lut.py
+src/pyholoscope/propagator.py
+src/pyholoscope/roi.py
+src/pyholoscope/sim.py
+src/pyholoscope/utils.py
+src/pyholoscope/windows.py

pyholoscope-1.0.0/src/PyHoloscope.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyholoscope-1.0.0/src/PyHoloscope.egg-info/requires.txt

@@ -0,0 +1,6 @@
+matplotlib>=3.3.4
+numba>=0.55.1
+numpy>=1.22
+opencv_python>=4.5
+Pillow>=9
+scipy>=1.7

pyholoscope-1.0.0/src/PyHoloscope.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyholoscope

pyholoscope-1.0.0/src/pyholoscope/__init__.py

@@ -0,0 +1,27 @@
+"""
+PyHoloscope - Fast Holographic Microscopy for Python
+"""
+
+INLINE = 1
+OFF_AXIS = 2
+
+INLINE_MODE = 1  # deprecated, kept for backwards compatibility
+OFFAXIS_MODE = 2  # deprecated, kept for backwards compatibility
+
+from pyholoscope.general import *
+from pyholoscope.off_axis import *
+from pyholoscope.utils import *
+from pyholoscope.prop_lut import *
+from pyholoscope.focus_stack import *
+from pyholoscope.roi import *
+from pyholoscope.holo_class import *
+from pyholoscope.focusing import *
+from pyholoscope.phase_proc import *
+from pyholoscope.windows import *
+
+
+try:
+    from pyholoscope.focusing_numba import *
+except:
+    pass
+from pyholoscope.focus_shift import *

pyholoscope-1.0.0/src/pyholoscope/focus_shift.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+"""
+PyHoloscope - Fast Holographic Microscopy for Python
+
+This file contains functions related to estimating depth from shifted images.
+
+This is experimental and does not form part of the documented API.
+
+"""
+
+import math
+import numpy as np
+
+try:
+    import cupy as cp
+
+    cudaAvailable = True
+except:
+    cudaAvailable = False
+from PIL import Image
+import cv2 as cv
+import scipy
+import time
+
+import cv2 as cv
+
+from pyholoscope.focus_stack import FocusStack
+from pyholoscope.focusing_numba import propagator_numba
+from pyholoscope.roi import Roi
+from pyholoscope.utils import extract_central
+import pyholoscope.general
+
+
+def determine_shift(img1, img2, **kwargs):
+    """Determines shift between two images by Normalised Cross Correlation (NCC). A sqaure template extracted
+    from the centre of img2 is compared with a sqaure region extracted from the reference image img1. The size
+    of the template (templateSize) must be less than the size of the reference (refSize). The maximum
+    detectable shift is the (refSize - templateSize) / 2.
+
+    Arguments:
+        img1     : numpy.ndarray
+                   reference image
+        img2     : numpy.ndarray
+                   image to be compared with reference
+
+    Keyword Arguments:
+        upsample : int
+                   factor to scale images by prior to template matching to
+                   allow for sub-pixel registration.
+    """
+
+    returnMax = kwargs.get("returnMax", False)
+    upsample = kwargs.get("upsample", 1)
+
+    refSize = np.shape(img1)[0] / 2
+    templateSize = np.shape(img1)[0] / 4
+
+    if (
+        refSize < templateSize
+        or min(np.shape(img1)) < refSize
+        or min(np.shape(img2)) < refSize
+    ):
+        return -1
+    else:
+        template = extract_central(img2, templateSize).astype("float32")
+        refIm = extract_central(img1, refSize).astype("float32")
+
+        if upsample != 1:
+            template = cv.resize(
+                template,
+                (np.shape(template)[0] * upsample, np.shape(template)[1] * upsample),
+            )
+            refIm = cv.resize(
+                refIm, (np.shape(refIm)[0] * upsample, np.shape(refIm)[0] * upsample)
+            )
+        res = cv.matchTemplate(template, refIm, cv.TM_CCORR_NORMED)
+        min_val, max_val, min_loc, max_loc = cv.minMaxLoc(res)
+        shift = [
+            (max_loc[0] - (refSize - templateSize) * upsample) / upsample,
+            (max_loc[1] - (refSize - templateSize) * upsample) / upsample,
+        ]
+
+        if returnMax:
+            return shift, max_val
+        else:
+            return shift
+
+
+def calibrate_depth_from_shift(img1, img2, depth):
+    pass

pyholoscope-1.0.0/src/pyholoscope/focus_stack.py

@@ -0,0 +1,212 @@
+# -*- coding: utf-8 -*-
+"""
+PyHoloscope - Fast Holographic Microscopy for Python
+
+Class to store stack of images numerically refocused to different depths.
+
+"""
+
+import math
+
+import numpy as np
+from PIL import Image
+
+
+################### Class for stack of images focused at different depths ####
+class FocusStack:
+    def __init__(self, img, depth_range, num_depths):
+        """Initialise instance of FocusStack class.
+
+        Arguments:
+            img        : numpy.ndarray
+                         example image of the correct size and type, 2D numpy array
+            num_depths : (float, float)
+                         tuple of min depth and max depth in stack
+            num_depths : int
+                         number of images to be stored in stack
+        """
+        self.stack = np.zeros(
+            (num_depths, np.shape(img)[0], np.shape(img)[1]), dtype=img.dtype
+        )
+        self.depths = np.linspace(depth_range[0], depth_range[1], num_depths)
+        self.min_depth = depth_range[0]
+        self.max_depth = depth_range[1]
+        self.num_depths = num_depths
+        self.depth_range = depth_range
+
+    def __str__(self):
+        return (
+            "Refocus stack. Min: "
+            + str(self.min_depth)
+            + ", Max: "
+            + str(self.max_depth)
+            + ", Num: "
+            + str(self.num_depths)
+            + ", Step: "
+            + str((self.max_depth - self.min_depth) / self.num_depths)
+        )
+
+    def add_idx(self, img, idx):
+        """Adds an image to a specific index position.
+
+        Arguments:
+            img      : ndarray
+                       image as a 2D numpy array
+            idx      : int
+                       index position
+        """
+        self.stack[idx, :, :] = img
+
+    def add_depth(self, img, depth):
+        """Adds an image to index position closest to the the specifed depth.
+
+        Arguments:
+            img      : ndarray
+                       image as a 2D numpy array
+            depth    : float
+                       refocus depth of image
+        """
+        self.stack[self.depth_to_index(depth), :, :] = img
+
+    def get_index(self, idx):
+        """Returns the refocused image stored at the specified index.
+
+        Arguments:
+            idx      : int
+                       index position to return image from
+
+        Returns:
+            numpy.ndarray : image
+
+        """
+        return self.stack[idx, :, :]
+
+    def get_depth(self, depth):
+        """Returns the closest refocused image to the specifed depth.
+
+        Arguments:
+            depth     : float
+                        depth to return image from
+
+        Returns:
+            numpy.ndarray : image
+
+        """
+        return self.get_index(self.depth_to_index(depth))
+
+    def get_depth_intensity(self, depth):
+        """Returns the amplitude of the refocused image closest to the specified depth.
+
+        Arguments:
+            depth     : float
+                        depth to return image from
+
+        Returns:
+            numpy.ndarray : image
+
+        """
+        return np.abs(self.get_depth(depth))
+
+    def get_index_intensity(self, idx):
+        """Return the amplitude of the refocused image at the specified index.
+
+        Arguments:
+            idx     : int
+                      index position to return image from
+
+        Returns:
+            numpy.ndarray : image
+
+        """
+        return np.abs(self.get_index(idx))
+
+    def depth_to_index(self, depth):
+        """Returns the index closest to the specified depth.
+
+        Arguments:
+            depth     : float
+                        depth to obtain closest index to
+
+        Returns:
+            int       : index
+
+        """
+        idx = round(
+            (depth - self.min_depth)
+            / (self.max_depth - self.min_depth)
+            * (self.num_depths - 1)
+        )
+        if idx < 0:
+            idx = 0
+        if idx > self.num_depths - 1:
+            idx = self.num_depths - 1
+        return idx
+
+    def index_to_depth(self, idx):
+        """Returns depth corresponding to the specified index.
+
+        Arguments:
+            idx     : int
+                      index position
+
+        Returns:
+            float   : depth
+
+        """
+        return self.depths[idx]
+
+    def write_intensity_to_tif(self, filename, autoContrast=True):
+        """Writes the amplitudes of the stack of refocused images to a 16 bit tif stack
+        If autoContrast == True, all images will be autoscaled (across the whole
+        stack, not individually) to use the full bit depth.
+
+        Arguments:
+            filename     : str
+                           path/file to save to, should have .tif extension.
+
+        Keyword Arguments:
+            autoContrast : boolean
+                           if True (default) images are autoscaled
+        """
+
+        if autoContrast:
+            maxVal = np.max(np.abs(self.stack))
+            minVal = np.min(np.abs(self.stack))
+
+        imlist = []
+        for m in self.stack:
+            if autoContrast:
+                im = np.abs(m).astype("float64") - minVal
+                im = im / (maxVal - minVal) * 2**16
+                imlist.append(Image.fromarray(im.astype("uint16")))
+
+            else:
+                imlist.append(Image.fromarray((255 * np.abs(m)).astype("uint16")))
+
+        imlist[0].save(
+            filename,
+            compression="tiff_deflate",
+            save_all=True,
+            append_images=imlist[1:],
+        )
+
+    def write_phase_to_tif(self, filename):
+        """Writes the phases of the stack of refocused images to a 16 bit tif stack.
+        -pi is mapped to 0, pi is mapped to 255.
+
+        Arguments:
+            filename     : str
+                           path/file to save to, should have .tif extension.
+        """
+
+        imlist = []
+        for m in self.stack:
+            im = (np.angle(m) + math.pi) * 255
+            imlist.append(Image.fromarray(im.astype("uint16")))
+
+        imlist[0].save(
+            filename,
+            compression="tiff_deflate",
+            save_all=True,
+            append_images=imlist[1:],
+        )