napari-dpr 0.1.0__cp311-cp311-win_amd64.whl

napari_dpr/dpr_core.pyx

@@ -0,0 +1,103 @@
+# distutils: language = c++
+import numpy as np
+cimport numpy as np
+from libc.math cimport fabs, ceil
+import scipy.ndimage as ndi
+from scipy.interpolate import RectBivariateSpline
+
+np.import_array()
+
+ctypedef np.float64_t DTYPE_t
+
+def dpr_set_parameters(double psf, double gain=1, double background=-1, temporal=None):
+    if background < 0:
+        background = ceil(17 * psf)
+    return {'gain': gain, 'background': background, 'temporal': temporal}
+
+cpdef tuple dpr_update_single(np.ndarray[DTYPE_t, ndim=2] i, double psf, dict opt):
+    cdef:
+        int h = i.shape[0]
+        int w = i.shape[1]
+        int r = <int>ceil(opt['background'])
+        double g = opt['gain']
+        np.ndarray[DTYPE_t, ndim=2] localmin = np.zeros((h, w))
+        np.ndarray[DTYPE_t, ndim=2] i_localmin = np.zeros((h, w))
+        int u, v
+
+    i = i - i.min()
+    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] = np.min(sub)
+            i_localmin[u, v] = i[u, v] - localmin[u, v]
+
+    psf /= 1.6651
+    x0 = np.linspace(-0.5, 0.5, w)
+    y0 = np.linspace(-0.5, 0.5, h)
+    x = np.linspace(-0.5, 0.5, round(5 * w / psf))
+    y = np.linspace(-0.5, 0.5, round(5 * h / psf))
+
+    interp_m = RectBivariateSpline(y0, x0, i_localmin)(y, x)
+    interp_m[interp_m < 0] = 0
+    interp_m = np.pad(interp_m, 10)
+
+    interp_i = RectBivariateSpline(y0, x0, i)(y, x)
+    interp_i[interp_i < 0] = 0
+    interp_i = np.pad(interp_i, 10)
+
+    hn, wn = interp_i.shape
+    norm = interp_m / (ndi.gaussian_filter(interp_m, 10) + 1e-5)
+
+    sobel_x = np.array([[1, 0, -1], [2, 0, -2], [1, 0, -1]])
+    sobel_y = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]])
+    gx = ndi.convolve(norm, sobel_y, mode='reflect') / (norm + 1e-5)
+    gy = ndi.convolve(norm, sobel_x, mode='reflect') / (norm + 1e-5)
+
+    gain_val = 0.5 * g + 1
+    dx = gain_val * gx
+    dy = gain_val * gy
+    dx[np.abs(dx) > 10] = 0
+    dy[np.abs(dy) > 10] = 0
+
+    out = np.zeros((hn, wn))
+    cdef int nx, ny, fx, fy, sx, sy
+    cdef double wx, wy, w1, w2, w3, w4, val
+
+    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 - fabs(wx - fx)) * (1 - fabs(wy - fy))
+            w2 = (1 - fabs(wx - fx)) * fabs(wy - fy)
+            w3 = fabs(wx - fx) * (1 - fabs(wy - fy))
+            w4 = fabs(wx - fx) * fabs(wy - fy)
+            val = interp_i[nx, ny]
+            out[nx + fx, ny + fy] += w1 * val
+            out[nx + fx, ny + fy + sy] += w2 * val
+            out[nx + fx + sx, ny + fy] += w3 * val
+            out[nx + fx + sx, ny + fy + sy] += w4 * val
+
+    return out[10:-10, 10:-10], interp_i[10:-10, 10:-10], g, r
+
+cpdef tuple dpr_stack(np.ndarray[DTYPE_t, ndim=3] s, double psf, dict opt):
+    cdef int f = s.shape[2]
+    dpr0, mag0, _, _ = dpr_update_single(s[:, :, 0], psf, opt)
+    shp = dpr0.shape
+    out = np.zeros((shp[0], shp[1], f))
+    mag = np.zeros((shp[0], shp[1], f))
+    cdef int i
+    for i in range(f):
+        dpr, m, _, _ = dpr_update_single(s[:, :, i], psf, opt)
+        out[:, :, i] = dpr
+        mag[:, :, i] = m
+    if opt.get('temporal') == 'mean':
+        out = np.mean(out, axis=2)
+    elif opt.get('temporal') == 'var':
+        out = np.var(out, axis=2)
+    return out, mag
+cpdef tuple apply_dpr(np.ndarray[DTYPE_t, ndim=3] im, double psf=4, double gain=2, double background=10, temporal='mean'):
+    if im.ndim == 2:
+        im = im[:, :, np.newaxis]
+    opt = dpr_set_parameters(psf, gain, background, temporal)
+    return dpr_stack(im, psf, opt)

napari_dpr/example.py

@@ -0,0 +1,46 @@
+"""
+Example script for using napari-dpr programmatically.
+"""
+import os
+import sys
+import numpy as np
+import matplotlib.pyplot as plt
+import napari
+from napari_dpr.dpr_core import apply_dpr
+from napari_dpr.run_dpr import run_example
+
+def example_with_test_image():
+    """Run an example using the test image or random data if not available."""
+    print("Running DPR example with test image...")
+    # run_example returns the dpr_out and magnified images
+    dpr_out, magnified = run_example()
+    print("Done.")
+
+def example_with_napari():
+    """Run an example using napari viewer."""
+    print("Running DPR example with napari...")
+    
+    # Create a random test image
+    test_image = np.random.random((100, 100, 5)).astype(np.float64)
+    
+    # Start napari viewer with the test image
+    viewer = napari.Viewer()
+    viewer.add_image(test_image, name='test_image')
+    
+    # Process the image with DPR
+    dpr_out, magnified = apply_dpr(test_image, psf=4.0)
+    
+    # Add the processed images to the viewer
+    viewer.add_image(dpr_out, name='DPR_enhanced')
+    viewer.add_image(magnified.sum(axis=2), name='magnified')
+    
+    # Start the napari event loop
+    napari.run()
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == '--napari':
+        example_with_napari()
+    else:
+        example_with_test_image()
+    
+    print("To run with napari viewer: python -m napari_dpr.example --napari") 

napari_dpr/napari.yaml

@@ -0,0 +1,10 @@
+name: napari-dpr
+display_name: DPR Resolution Enhancement
+contributions:
+  commands:
+    - id: napari-dpr.enhance_image
+      title: Enhance resolution with DPR
+      python_name: napari_dpr._widget:enhance_image
+  widgets:
+    - command: napari-dpr.enhance_image
+      display_name: DPR Enhancement 

napari_dpr/run.dpr.py

@@ -0,0 +1,68 @@
+# run_dpr.py
+import os
+import numpy as np
+import tifffile as tf
+from napari_dpr.dpr_core import apply_dpr
+import matplotlib.pyplot as plt
+import time
+from pathlib import Path
+
+def run_example(input_file=None):
+    """Run DPR on an example image file."""
+    
+    # If no input file is provided, try to find the test image in standard locations
+    if input_file is None:
+        # Try several possible locations for the test image
+        possible_paths = [
+            "test_data/test_image.tif",            # Repository structure
+            "../test_data/test_image.tif",         # If run from src directory
+            "../../test_data/test_image.tif",      # If run from deeper directory
+            os.path.join(os.path.dirname(__file__), '../../test_data/test_image.tif')  # Relative to script
+        ]
+        
+        for path in possible_paths:
+            if os.path.exists(path):
+                input_file = path
+                break
+        
+        if input_file is None:
+            # If no test image is found, generate a random one
+            print("No test image found, generating random data...")
+            input_image = np.random.rand(64, 64, 5).astype(np.float64)
+        else:
+            print(f"Using test image: {input_file}")
+    else:
+        print(f"Using provided image: {input_file}")
+    
+    # Load the image if a file was found or provided
+    if input_file is not None:
+        input_image = tf.imread(input_file)
+        # Ensure correct dimensions (HEIGHT, WIDTH, TIME)
+        if input_image.ndim == 3 and input_image.shape[0] < input_image.shape[1]:
+            input_image = input_image.transpose([1, 2, 0])
+    
+    # Ensure 3D image (HEIGHT, WIDTH, TIME)
+    if input_image.ndim == 2:
+        input_image = input_image[:, :, np.newaxis]
+    
+    # Process with DPR
+    print(f"Processing image of shape {input_image.shape}...")
+    start = time.time()
+    dpr_out, magnified = apply_dpr(input_image, psf=4.0)
+    print(f"Time taken: {time.time() - start:.2f} seconds")
+    
+    # Display results
+    plt.figure(figsize=(12, 6))
+    plt.subplot(121)
+    plt.title("Original (Magnified)")
+    plt.imshow(magnified.sum(2))
+    plt.subplot(122)
+    plt.title("DPR Enhanced")
+    plt.imshow(dpr_out)
+    plt.tight_layout()
+    plt.show()
+    
+    return dpr_out, magnified
+
+if __name__ == "__main__":
+    run_example()

napari_dpr-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,19 @@
+napari_dpr/__init__.py,sha256=HFUdQMoqtTsOemML-GXsGoAC8q-EGgfAbqgQzhqfRwY,165
+napari_dpr/_widget.py,sha256=LrK4YI6hLRAWMXPEsyBWuvmgx3OctScp1rW0hLnixlI,2932
+napari_dpr/dpr.py,sha256=6pNcqYCI7HQXJv2nU33ZFyhEJu4Po5Fo3xG5Z1L8WIc,5267
+napari_dpr/dpr_core.cp310-win_amd64.pyd,sha256=XSPkw-7w569QoqQytaG7Qr2c-4tefdOF91GfzsoSI94,102912
+napari_dpr/dpr_core.cp311-win_amd64.pyd,sha256=BBJt5ZE8xOT7E15eCgRnUzGuxX7zYHU535RBPxS-rq4,103424
+napari_dpr/dpr_core.cp312-win_amd64.pyd,sha256=CCpiLdPcziOmnP9l6psT1tUDTRiWMqqOxvVu-74QpX8,102400
+napari_dpr/dpr_core.cp313-win_amd64.pyd,sha256=ZD7GLCDa5D2QzTWAKOVXfv69Zw6oJ6Op1ryw-Vs9lLc,101888
+napari_dpr/dpr_core.cp39-win_amd64.pyd,sha256=YnljIT3EbCAuhz1w2pHmi4HfIj7xUb7wUNtoLnFAcOY,102912
+napari_dpr/dpr_core.cpp,sha256=ynsq30HyYVN_rSID2rUj2e0_lPdyhxsAZ3w-b7k-SvI,617011
+napari_dpr/dpr_core.pyx,sha256=GGnCR37RnWW_IDBHwuqrCevCUJHo5p7cNhQyKUQlvIs,3804
+napari_dpr/example.py,sha256=n5gKHk70XL3VyvjJvJq6S6k7onPu0s_X6VCArfDomFw,1472
+napari_dpr/napari.yaml,sha256=52yyMHUE3xPkS-3rVPKhqRRDXN2fyF6mjS021FzihkA,309
+napari_dpr/run.dpr.py,sha256=NDr2QhzYMjr0ZqudspgzOCZhMxaqRrbejwaS7lPs6_4,2427
+napari_dpr-0.1.0.dist-info/licenses/LICENSE,sha256=fG9FETcFv5KCjRjPEb6STyAZKUMRQbLDJzc9Rgy728M,1082
+napari_dpr-0.1.0.dist-info/METADATA,sha256=MGXs35HRiqrZaiiryQvINwoYbQH4_RUIuDJe7ygfwdw,6142
+napari_dpr-0.1.0.dist-info/WHEEL,sha256=pkI-s5KKCTCXRcuamRCpmUHK9lBRiVf1mC9_VUZSXgc,101
+napari_dpr-0.1.0.dist-info/entry_points.txt,sha256=EWQt54qiAOwySprF_niJSapFgqHgkTB2TNnyYXiVQa0,54
+napari_dpr-0.1.0.dist-info/top_level.txt,sha256=i9hH6jDl1Ge8GHx1LoWvm1k5DLu4b7-59b5ceuaWxuI,11
+napari_dpr-0.1.0.dist-info/RECORD,,

napari_dpr-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.1)
+Root-Is-Purelib: false
+Tag: cp311-cp311-win_amd64
+

napari_dpr-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[napari.manifest]
+napari-dpr = napari_dpr:napari.yaml

napari_dpr-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+napari_dpr