napari-dpr 0.1.0__cp312-cp312-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/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,41 @@
+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
+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"

napari_dpr-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+napari_dpr/__init__.py,sha256=HFUdQMoqtTsOemML-GXsGoAC8q-EGgfAbqgQzhqfRwY,165
+napari_dpr/_widget.py,sha256=_4c3sK7JQGcBR97SHkh8EkSULcw_O0IE9kaRXY-lT44,2933
+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=VmFCAzAHVzCk4mcMBg8EBryLjMQoPRwALk47v1y5ktk,103424
+napari_dpr/dpr_core.cp312-win_amd64.pyd,sha256=CCpiLdPcziOmnP9l6psT1tUDTRiWMqqOxvVu-74QpX8,102400
+napari_dpr/dpr_core.cp39-win_amd64.pyd,sha256=YnljIT3EbCAuhz1w2pHmi4HfIj7xUb7wUNtoLnFAcOY,102912
+napari_dpr/dpr_core.cpp,sha256=vA_q9YKFdjR0zum6jiUDicGLamarxZjUya6Iagx6OXA,621646
+napari_dpr/dpr_core.pyx,sha256=GGnCR37RnWW_IDBHwuqrCevCUJHo5p7cNhQyKUQlvIs,3804
+napari_dpr/napari.yaml,sha256=52yyMHUE3xPkS-3rVPKhqRRDXN2fyF6mjS021FzihkA,309
+napari_dpr/run.dpr.py,sha256=NDr2QhzYMjr0ZqudspgzOCZhMxaqRrbejwaS7lPs6_4,2427
+napari_dpr-0.1.0.dist-info/METADATA,sha256=6H1apAE54fyczp5aCUQQ3xF_Kf3dTxavZDnOAqh3hCk,1652
+napari_dpr-0.1.0.dist-info/WHEEL,sha256=KI7LHhz6dTtDDO7VYe8QnwL5I_g0fgqsSHIhDBBaEVw,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: cp312-cp312-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/top_level.txt

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