Update app.py

app.py

@@ -1,5 +1,4 @@
 import numpy as np
-import scipy as sp
 from numba import njit, prange, vectorize
 import gradio as gr
 
@@ -20,49 +19,21 @@ def neighbours(y, x, max_y, max_x):
         n.append((y, x+1))
     return n
 
-@njit(parallel=True)
-def poisson_sharpening(img, alpha):
-    """
-    Returns a sharpened image with strength of alpha.
-    :param img: the image
-    :param alpha: edge threshold and gradient scaler
-    """
+@njit
+def poisson_sharpening(img, alpha, num_iterations=50):
     img_h, img_w = img.shape
-    img_s = img.copy()
-    
-    im2var = np.arange(img_h * img_w).reshape(img_h, img_w)
+    v = img.copy()
     
-    A_data = np.zeros(img_h * img_w * 4 * 2, dtype=np.float64)
-    A_row = np.zeros(img_h * img_w * 4 * 2, dtype=np.int32)
-    A_col = np.zeros(img_h * img_w * 4 * 2, dtype=np.int32)
-    b = np.zeros(img_h * img_w * 4 * 2, dtype=np.float64)
+    for _ in range(num_iterations):
+        for y in range(img_h):
+            for x in range(img_w):
+                neighbors = neighbours(y, x, img_h-1, img_w-1)
+                num_neighbors = len(neighbors)
+                neighbor_sum = sum(v[ny, nx] for ny, nx in neighbors)
+                laplacian = neighbor_sum - num_neighbors * v[y, x]
+                v[y, x] += (laplacian + alpha * (img[y, x] - v[y, x])) / (num_neighbors + alpha)
     
-    e = 0
-    for y in prange(img_h):
-        for x in prange(img_w):
-            A_data[e] = 1
-            A_row[e] = e
-            A_col[e] = im2var[y, x]
-            b[e] = img_s[y, x]
-            e += 1
-            
-            for n_y, n_x in neighbours(y, x, img_h-1, img_w-1):
-                A_data[e] = 1
-                A_row[e] = e
-                A_col[e] = im2var[y, x]
-                e += 1
-                
-                A_data[e] = -1
-                A_row[e] = e - 1
-                A_col[e] = im2var[n_y, n_x]
-                
-                b[e-1] = alpha * (img_s[y, x] - img_s[n_y, n_x])
-                e += 1
-    
-    A = sp.sparse.csr_matrix((A_data[:e], (A_row[:e], A_col[:e])), shape=(e, img_h * img_w))
-    v = sp.sparse.linalg.lsqr(A, b[:e])[0]
-
-    return clip(v.reshape(img_h, img_w), 1.0)
+    return clip(v, 1.0)
 
 @njit(parallel=True)
 def sharpen_image(img, alpha):