napari-dpr 0.1.0__tar.gz

napari_dpr-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 JenuC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

napari_dpr-0.1.0/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: napari-dpr
+Version: 0.1.0
+Summary: Napari plugin for DPR Resolution Enhancement
+Author-email: JenuC <jenu.chacko@wisc.edu>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jenuc/napari-dpr
+Project-URL: Bug Tracker, https://github.com/jenuc/napari-dpr/issues
+Project-URL: Documentation, https://github.com/jenuc/napari-dpr#README.md
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: napari
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: napari>=0.4.18
+Requires-Dist: numpy>=1.24.3
+Requires-Dist: scipy>=1.10.1
+Requires-Dist: matplotlib>=3.7.2
+Requires-Dist: cython>=0.29.0
+Requires-Dist: setuptools>=42.0.0
+Requires-Dist: tifffile
+Requires-Dist: pillow
+Requires-Dist: magicgui>=0.5.0
+Requires-Dist: qtpy
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: cibuildwheel; extra == "dev"
+Provides-Extra: testing
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pytest-qt; extra == "testing"
+Dynamic: license-file
+
+# napari-dpr
+
+[![License MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://img.shields.io/pypi/v/napari-dpr.svg)](https://pypi.org/project/napari-dpr)
+[![Python Version](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue.svg)](https://python.org)
+[![napari hub](https://img.shields.io/badge/napari-hub-purple.svg)](https://napari-hub.org/plugins/napari-dpr)
+
+> ## ⚠️ IMPORTANT: Original Work Acknowledgment
+> This napari plugin is based on and extends the work from the original [DPR-Resolution_enhancement_with_deblurring_by_pixel_reassignment](https://github.com/biomicroscopy/DPR-Resolution_enhancement_with_deblurring_by_pixel_reassignment) repository. 
+>
+> The algorithm was originally developed by Zhao, B. and Mertz, J., as described in their paper ["Resolution enhancement with deblurring by pixel reassignment (DPR)"](https://www.spiedigitallibrary.org/journals/advanced-photonics/volume-5/issue-06/066004/Resolution-enhancement-with-deblurring-by-pixel-reassignment/10.1117/1.AP.5.6.066004.full) (DOI: 10.1117/1.AP.5.6.066004).
+>
+> <img src="docs/images/schematic.png" alt="DPR Algorithm Schematic" width="50%">
+>
+> **If you use this plugin for your research, please cite the original paper:**
+> ```
+> Zhao, B., and Mertz, J. "Resolution enhancement with deblurring by pixel reassignment (DPR)." 
+> Advanced Photonics, 5(6), 066004 (2023). DOI: 10.1117/1.AP.5.6.066004
+> ```
+
+A napari plugin for image resolution enhancement using Deconvolution by Pixel Reassignment (DPR).
+
+## Description
+
+DPR is a technique for enhancing the resolution of images, particularly useful in microscopy. This plugin provides easy access to DPR functionality within napari, allowing for quick and intuitive image enhancement without leaving your viewer.
+
+The algorithm works by:
+1. Applying a specialized deconvolution approach
+2. Reassigning pixels based on local information
+3. Enhancing fine details while preserving image structure
+
+## Installation
+
+You can install `napari-dpr` via [pip]:
+
+```bash
+pip install napari-dpr
+```
+
+## Usage
+
+1. Open napari and load an image
+2. In the menu, go to `Plugins > DPR Enhancement`
+3. Select your image from the dropdown
+4. Adjust parameters as needed:
+   - **PSF**: Point spread function size (typical values: 2-6)
+   - **Gain**: Enhancement gain (typical values: 1-3)
+   - **Background**: Background subtraction (typical values: 5-20)
+5. Click "Enhance Resolution"
+6. Two new layers will be added to your viewer:
+   - `[original_name]_DPR_enhanced`: The DPR-enhanced image
+   - `[original_name]_magnified`: The magnified original for comparison
+
+## Parameters
+
+- **PSF** (Point Spread Function): Controls the width of the point spread function used in the algorithm. Larger values capture wider spatial correlations but may reduce detail resolution.
+- **Gain**: Controls the enhancement strength. Higher values increase contrast but may introduce artifacts.
+- **Background**: Controls background subtraction. Higher values remove more background but may affect relevant image features.
+
+## Standalone Usage
+
+You can also use the DPR algorithm programmatically:
+
+```python
+from napari_dpr.dpr_core import apply_dpr
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Load your image data (should be 3D: HEIGHT, WIDTH, TIME)
+image_data = your_image_loading_function()
+if image_data.ndim == 2:
+    image_data = image_data[:, :, np.newaxis]  # Add time dimension if 2D
+
+# Apply DPR
+dpr_enhanced, magnified = apply_dpr(image_data, psf=4.0, gain=2.0, background=10.0)
+
+# Visualize results
+plt.figure(figsize=(12, 6))
+plt.subplot(121)
+plt.title("Original (Magnified)")
+plt.imshow(magnified.sum(axis=2))
+plt.subplot(122)
+plt.title("DPR Enhanced")
+plt.imshow(dpr_enhanced)
+plt.tight_layout()
+plt.show()
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+Distributed under the terms of the [MIT] license,
+"napari-dpr" is free and open source software.
+
+## Issues
+
+If you encounter any problems, please [file an issue] along with a detailed description.
+
+[file an issue]: https://github.com/jenuc/napari-dpr/issues
+[napari]: https://github.com/napari/napari
+[pip]: https://pypi.org/project/pip/
+[MIT]: https://opensource.org/licenses/MIT

napari_dpr-0.1.0/README.md

@@ -0,0 +1,105 @@
+# napari-dpr
+
+[![License MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://img.shields.io/pypi/v/napari-dpr.svg)](https://pypi.org/project/napari-dpr)
+[![Python Version](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue.svg)](https://python.org)
+[![napari hub](https://img.shields.io/badge/napari-hub-purple.svg)](https://napari-hub.org/plugins/napari-dpr)
+
+> ## ⚠️ IMPORTANT: Original Work Acknowledgment
+> This napari plugin is based on and extends the work from the original [DPR-Resolution_enhancement_with_deblurring_by_pixel_reassignment](https://github.com/biomicroscopy/DPR-Resolution_enhancement_with_deblurring_by_pixel_reassignment) repository. 
+>
+> The algorithm was originally developed by Zhao, B. and Mertz, J., as described in their paper ["Resolution enhancement with deblurring by pixel reassignment (DPR)"](https://www.spiedigitallibrary.org/journals/advanced-photonics/volume-5/issue-06/066004/Resolution-enhancement-with-deblurring-by-pixel-reassignment/10.1117/1.AP.5.6.066004.full) (DOI: 10.1117/1.AP.5.6.066004).
+>
+> <img src="docs/images/schematic.png" alt="DPR Algorithm Schematic" width="50%">
+>
+> **If you use this plugin for your research, please cite the original paper:**
+> ```
+> Zhao, B., and Mertz, J. "Resolution enhancement with deblurring by pixel reassignment (DPR)." 
+> Advanced Photonics, 5(6), 066004 (2023). DOI: 10.1117/1.AP.5.6.066004
+> ```
+
+A napari plugin for image resolution enhancement using Deconvolution by Pixel Reassignment (DPR).
+
+## Description
+
+DPR is a technique for enhancing the resolution of images, particularly useful in microscopy. This plugin provides easy access to DPR functionality within napari, allowing for quick and intuitive image enhancement without leaving your viewer.
+
+The algorithm works by:
+1. Applying a specialized deconvolution approach
+2. Reassigning pixels based on local information
+3. Enhancing fine details while preserving image structure
+
+## Installation
+
+You can install `napari-dpr` via [pip]:
+
+```bash
+pip install napari-dpr
+```
+
+## Usage
+
+1. Open napari and load an image
+2. In the menu, go to `Plugins > DPR Enhancement`
+3. Select your image from the dropdown
+4. Adjust parameters as needed:
+   - **PSF**: Point spread function size (typical values: 2-6)
+   - **Gain**: Enhancement gain (typical values: 1-3)
+   - **Background**: Background subtraction (typical values: 5-20)
+5. Click "Enhance Resolution"
+6. Two new layers will be added to your viewer:
+   - `[original_name]_DPR_enhanced`: The DPR-enhanced image
+   - `[original_name]_magnified`: The magnified original for comparison
+
+## Parameters
+
+- **PSF** (Point Spread Function): Controls the width of the point spread function used in the algorithm. Larger values capture wider spatial correlations but may reduce detail resolution.
+- **Gain**: Controls the enhancement strength. Higher values increase contrast but may introduce artifacts.
+- **Background**: Controls background subtraction. Higher values remove more background but may affect relevant image features.
+
+## Standalone Usage
+
+You can also use the DPR algorithm programmatically:
+
+```python
+from napari_dpr.dpr_core import apply_dpr
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Load your image data (should be 3D: HEIGHT, WIDTH, TIME)
+image_data = your_image_loading_function()
+if image_data.ndim == 2:
+    image_data = image_data[:, :, np.newaxis]  # Add time dimension if 2D
+
+# Apply DPR
+dpr_enhanced, magnified = apply_dpr(image_data, psf=4.0, gain=2.0, background=10.0)
+
+# Visualize results
+plt.figure(figsize=(12, 6))
+plt.subplot(121)
+plt.title("Original (Magnified)")
+plt.imshow(magnified.sum(axis=2))
+plt.subplot(122)
+plt.title("DPR Enhanced")
+plt.imshow(dpr_enhanced)
+plt.tight_layout()
+plt.show()
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+Distributed under the terms of the [MIT] license,
+"napari-dpr" is free and open source software.
+
+## Issues
+
+If you encounter any problems, please [file an issue] along with a detailed description.
+
+[file an issue]: https://github.com/jenuc/napari-dpr/issues
+[napari]: https://github.com/napari/napari
+[pip]: https://pypi.org/project/pip/
+[MIT]: https://opensource.org/licenses/MIT

napari_dpr-0.1.0/pyproject.toml

@@ -0,0 +1,84 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel", "cython>=0.29.0", "numpy>=1.24.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "napari-dpr"
+version = "0.1.0"
+description = "Napari plugin for DPR Resolution Enhancement"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [
+    {name = "JenuC", email = "jenu.chacko@wisc.edu"}
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10", 
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+    "Framework :: napari",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+    "Topic :: Scientific/Engineering :: Image Processing",
+]
+dependencies = [
+    "napari>=0.4.18",
+    "numpy>=1.24.3",
+    "scipy>=1.10.1",
+    "matplotlib>=3.7.2",
+    "cython>=0.29.0",
+    "setuptools>=42.0.0",
+    "tifffile",
+    "pillow",
+    "magicgui>=0.5.0",
+    "qtpy",
+]
+
+[project.optional-dependencies]
+dev = ["pytest", "build", "twine", "cibuildwheel"]
+testing = ["pytest", "pytest-qt"]
+
+[project.urls]
+"Homepage" = "https://github.com/jenuc/napari-dpr"
+"Bug Tracker" = "https://github.com/jenuc/napari-dpr/issues"
+"Documentation" = "https://github.com/jenuc/napari-dpr#README.md"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+packages = ["napari_dpr"]
+
+[tool.setuptools.package-data]
+"napari_dpr" = ["*.yaml", "*.pyx", "*.pyd"]
+
+[project.entry-points."napari.manifest"]
+napari-dpr = "napari_dpr:napari.yaml"
+
+# Configuration for building wheels
+[tool.cibuildwheel]
+# Python versions to build wheels for - use underscore to separate items
+build = ["cp39-*", "cp310-*", "cp311-*", "cp312-*", "cp313-*"]
+# Skip 32-bit builds and musllinux builds
+skip = ["*-win32", "*-manylinux_i686", "*-musllinux_*"]
+
+# Build only for 64-bit architectures
+archs = ["auto64"]
+
+# Configure environment variables for building
+[tool.cibuildwheel.environment]
+CFLAGS = "-O3"
+CXXFLAGS = "-O3"
+
+# Windows specific settings
+[tool.cibuildwheel.windows]
+# Explicitly target 64-bit Windows for specific Python versions
+build = ["cp39-win_amd64", "cp310-win_amd64", "cp311-win_amd64", "cp312-win_amd64", "cp313-win_amd64"]
+
+# macOS specific settings
+[tool.cibuildwheel.macos]
+# Target only 64-bit builds for macOS
+archs = ["x86_64", "arm64"]

napari_dpr-0.1.0/setup.cfg

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

napari_dpr-0.1.0/setup.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+from setuptools import setup, Extension, find_packages
+from Cython.Build import cythonize
+import numpy as np
+import sys
+import os
+
+# Ensure we're building extensions inplace
+if 'build_ext' not in sys.argv:
+    sys.argv.append('build_ext')
+if '--inplace' not in sys.argv:
+    sys.argv.append('--inplace')
+
+# Make sure the compiled .pyd file can be imported from the package
+if not os.path.exists("src/napari_dpr"):
+    os.makedirs("src/napari_dpr", exist_ok=True)
+
+# Define the extension module - using correct package path
+ext_modules = [
+    Extension(
+        "napari_dpr.dpr_core",  # This will create dpr_core.pyd in the napari_dpr package
+        ["src/napari_dpr/dpr_core.pyx"],  # Source file in the napari_dpr package
+        include_dirs=[np.get_include()],
+        language="c++",
+        define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")],
+        extra_compile_args=["-O3"],
+    ),
+]
+
+setup(
+    ext_modules=cythonize(
+        ext_modules,
+        compiler_directives={
+            'language_level': 3,
+            'boundscheck': False,
+            'wraparound': False,
+            'cdivision': True,
+        }
+    ),
+    # Ensure the extension is properly placed in the package directory
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+) 

napari_dpr-0.1.0/src/napari_dpr/__init__.py

@@ -0,0 +1,9 @@
+"""
+napari-dpr plugin package.
+"""
+
+__version__ = "0.1.0"
+
+# Import modules for easier access
+from napari_dpr.dpr_core import *
+from napari_dpr.dpr import * 

napari_dpr-0.1.0/src/napari_dpr/_widget.py

@@ -0,0 +1,88 @@
+"""
+Napari plugin widget for DPR resolution enhancement.
+"""
+from typing import TYPE_CHECKING
+import numpy as np
+from magicgui import magic_factory
+from napari_dpr.dpr_core import apply_dpr
+
+if TYPE_CHECKING:
+    import napari
+
+@magic_factory(
+    psf={"widget_type": "FloatSpinBox", "min": 1.0, "max": 10.0, "step": 0.1, "value": 4.0},
+    gain={"widget_type": "FloatSpinBox", "min": 0.1, "max": 10.0, "step": 0.1, "value": 2.0},
+    background={"widget_type": "FloatSpinBox", "min": 0.0, "max": 50.0, "step": 1.0, "value": 10.0},
+    call_button="Enhance Resolution"
+)
+def enhance_image(
+    viewer: "napari.viewer.Viewer",
+    image_layer: "napari.layers.Image",
+    psf: float = 4.0,
+    gain: float = 2.0,
+    background: float = 10.0,
+) -> None:
+    """
+    Enhance image resolution using DPR.
+    
+    Parameters
+    ----------
+    viewer : napari.viewer.Viewer
+        Napari viewer instance
+    image_layer : napari.layers.Image
+        Input image layer to enhance
+    psf : float
+        Point spread function size parameter
+    gain : float
+        Gain parameter for enhancement
+    background : float
+        Background subtraction value
+    """
+    if image_layer is None:
+        raise ValueError("Please select an image layer")
+    
+    # Get the image data
+    image_data = image_layer.data
+    
+    # Make sure image has the right dimensions and type
+    # DPR expects a 3D array (HEIGHT, WIDTH, TIME/CHANNELS)
+    if image_data.ndim == 2:
+        # Convert 2D image to 3D with one time point
+        image_data = image_data[:, :, np.newaxis]
+    elif image_data.ndim == 3 and image_data.shape[0] < image_data.shape[1]:
+        # If first dimension is smallest, it's probably [TIME, HEIGHT, WIDTH]
+        # We need to transpose to [HEIGHT, WIDTH, TIME]
+        image_data = image_data.transpose([1, 2, 0])
+    elif image_data.ndim > 3:
+        # If 4D or more, take the first 3 dimensions
+        image_data = image_data[:, :, :, 0]
+        
+    # Ensure data is float64
+    if image_data.dtype != np.float64:
+        image_data = image_data.astype(np.float64)
+    
+    # Apply DPR
+    try:
+        dpr_out, magnified = apply_dpr(image_data, psf=psf, gain=gain, background=background)
+        
+
+        
+        # Add the magnified original for comparison
+        viewer.add_image(
+            magnified.sum(axis=2),  # Sum over the time/channel dimension
+            name=f"{image_layer.name}_magnified",
+            colormap=image_layer.colormap.name,
+        )
+
+        # Add the enhanced image to the viewer
+        viewer.add_image(
+            dpr_out,
+            name=f"{image_layer.name}_DPR_enhanced",
+            colormap=image_layer.colormap.name,
+        )
+        
+    except Exception as e:
+        import traceback
+        print(f"Error applying DPR: {e}")
+        print(traceback.format_exc())
+        raise 

napari_dpr-0.1.0/src/napari_dpr/dpr.py

@@ -0,0 +1,131 @@
+import os, sys, time, numpy as np, scipy.ndimage as ndi
+from scipy.interpolate import RectBivariateSpline
+import tifffile as tiff
+from PIL import Image
+import matplotlib.pyplot as plt
+
+## original DPR as shown by https://github.com/biomicroscopy/DPR-Resolution_enhancement_with_deblurring_by_pixel_reassignment
+
+def dpr_set_parameters(psf, **k): return {'gain': k.get('gain',1), 'background': k.get('background',int(np.ceil(17*psf))), 'temporal': k.get('temporal',None)}
+
+def dpr_update_single(i, psf, opt):
+    g, r = opt['gain'], int(np.ceil(opt['background']))
+    psf /= 1.6651
+    h, w = i.shape
+    x0, y0 = np.linspace(-.5,.5,w), np.linspace(-.5,.5,h)
+    x, y = np.linspace(-.5,.5,round(5*w/psf)), np.linspace(-.5,.5,round(5*h/psf))
+    sx, sy = np.array([[1,0,-1],[2,0,-2],[1,0,-1]]), np.array([[1,2,1],[0,0,0],[-1,-2,-1]])
+    i = i - i.min()
+    localmin = np.zeros_like(i)
+    i_localmin = np.zeros_like(i)
+    for u in range(h):
+        for v in range(w):
+            sub = i[max(0,u-r):min(h,u+r+1), max(0,v-r):min(w,v+r+1)]
+            localmin[u,v] = sub.min()
+            i_localmin[u,v] = i[u,v] - localmin[u,v]
+    m = RectBivariateSpline(y0,x0,i_localmin)(y,x)
+    m[m<0] = 0
+    m = np.pad(m,10)
+    mag = RectBivariateSpline(y0,x0,i)(y,x)
+    mag[mag<0] = 0
+    mag = np.pad(mag,10)
+    hn, wn = mag.shape
+    norm = m / (ndi.gaussian_filter(m,10)+1e-5)
+    gx = ndi.convolve(norm, sy, mode='reflect') / (norm + 1e-5)
+    gy = ndi.convolve(norm, sx, mode='reflect') / (norm + 1e-5)
+    d = 0.5*g+1
+    dx, dy = d*gx, d*gy
+    dx[np.abs(dx)>10] = 0
+    dy[np.abs(dy)>10] = 0
+    out = np.zeros((hn, wn))
+    for nx in range(10, hn-10):
+        for ny in range(10, wn-10):
+            wx, wy = dx[nx,ny], dy[nx,ny]
+            fx, fy = int(wx), int(wy)
+            sx, sy = int(np.sign(wx)), int(np.sign(wy))
+            w1 = (1-abs(wx-fx))*(1-abs(wy-fy))
+            w2 = (1-abs(wx-fx))*abs(wy-fy)
+            w3 = abs(wx-fx)*(1-abs(wy-fy))
+            w4 = abs(wx-fx)*abs(wy-fy)
+            c1 = [fx, fy]
+            c2 = [fx, fy+sy]
+            c3 = [fx+sx, fy]
+            c4 = [fx+sx, fy+sy]
+            val = mag[nx,ny]
+            out[nx+c1[0], ny+c1[1]] += w1*val
+            out[nx+c2[0], ny+c2[1]] += w2*val
+            out[nx+c3[0], ny+c3[1]] += w3*val
+            out[nx+c4[0], ny+c4[1]] += w4*val
+    return out[10:-10,10:-10], mag[10:-10,10:-10], g, r
+
+def dpr_stack(s, psf, o):
+    f = s.shape[2]
+    shp = dpr_update_single(s[:,:,0],psf,o)[1].shape
+    out = np.zeros((*shp,f)); mag = np.zeros((*shp,f))
+    for i in range(f):
+        sys.stdout.write(f"\rProcessing {i+1}/{f}"); sys.stdout.flush()
+        o1,o2,_,_ = dpr_update_single(s[:,:,i],psf,o)
+        out[:,:,i], mag[:,:,i] = o1, o2
+    t = o.get('temporal','')
+    if t == 'mean': out = np.mean(out,axis=2)
+    elif t == 'var': out = np.var(out,axis=2)
+    return out, mag
+
+def load_image_stack(p,n,t):
+    path = os.path.join(p,f'{n}.{t}')
+    if t.lower() == 'tif':
+        d = tiff.imread(path)
+        return np.transpose(d,(1,2,0)) if d.ndim==3 else d
+    return np.array(Image.open(path))
+
+def save_image(im, p, n, t):
+    os.makedirs(p, exist_ok=True)
+    f = os.path.join(p, f'{n}.{t}')
+    if t.lower()=='tif': tiff.imwrite(f, im)
+    else:
+        if im.dtype != np.uint8:
+            im = ((im-im.min())/(im.max()-im.min())*255).astype(np.uint8)
+        Image.fromarray(im).save(f)
+
+def process_image(p,n,t,psf,o):
+    s = load_image_stack(p,n,t)
+    out, mag = dpr_stack(s, psf, o)
+    save_image(out, os.path.join(p,'DPR_results'), f'{n}_result', t)
+    return s, out, mag
+
+def display_images(i,m,o):
+    plt.figure(figsize=(12,4))
+    plt.subplot(1,3,1); plt.imshow(i[...,0] if i.ndim==3 else i, cmap='gray'); plt.title('Initial')
+    plt.subplot(1,3,2); plt.imshow(np.mean(m,axis=2) if m.ndim==3 else m, cmap='gray'); plt.title('Magnified')
+    plt.subplot(1,3,3); plt.imshow(o, cmap='gray'); plt.title('DPR')
+    plt.tight_layout(); plt.show()
+
+def main():
+    p = r'test_data'
+    f = input("File name [test_image.tif]: ") or "test_image.tif"
+    n,t = f.rsplit('.',1)
+    mode = input("Use default params? y/n/e [y]: ").lower() or 'y'
+    if mode == 'e':
+        print("PSF: blur radius\nGain: enhancement\nBackground: subtraction\nTemporal: mean or var")
+        mode = input("Use default now? y/n [y]: ").lower() or 'y'
+    if mode == 'y': psf,g,bg,tmp = 4,2,10,'mean'
+    else:
+        psf = float(input("PSF [4]: ") or 4)
+        g = float(input("Gain [2]: ") or 2)
+        bg = float(input("Background [10]: ") or 10)
+        tmp = input("Temporal [mean]: ") or 'mean'
+    o = dpr_set_parameters(psf, gain=g, background=bg, temporal=tmp)
+    start = time.time()
+    res = process_image(p,n,t,psf,o)
+    if res:
+        img,dpr,mag = res
+        print(f"\nTime: {time.time()-start:.2f}s")
+        display_images(img,mag,dpr)
+    else: print("Failed.")
+
+def apply_dpr(im, psf=4, gain=2, background=10, temporal='mean'):
+    if im.ndim == 2: im = im[:,:,np.newaxis]
+    o = dpr_set_parameters(psf, gain=gain, background=background, temporal=temporal)
+    return dpr_stack(im, psf, o)
+
+if __name__ == '__main__': main()