push probelms

Author: weiykong

examples/compare_interfaces.py

@@ -99,7 +99,8 @@ def run_final_comparison(img_path='data/example.tif'):
     ax3 = fig.add_subplot(gs[0, 2])
     # Plotting Correlation Scatter
     ax3.scatter(P_bayes_z[valid_p], P_lap_z[valid_p], alpha=0.5, c='k', s=10)
-    ax3.set_xlabel("Bayesian P"); ax3.set_ylabel("Laplace P")
+    ax3.set_xlabel("Bayesian P")
+    ax3.set_ylabel("Laplace P")
     ax3.set_title(f"Pressure Correlation: {corr_p:.2f}")
     ax3.grid(True, alpha=0.3)
 
@@ -118,7 +119,8 @@ def run_final_comparison(img_path='data/example.tif'):
         ax6.text(0.5, 0.5, "Laplace Tension is Constant\n(No Correlation)", ha='center', va='center')
     else:
         ax6.scatter(T_bayes_aligned, T_lap_aligned, alpha=0.5, c='k', s=10)
-    ax6.set_xlabel("Bayesian T"); ax6.set_ylabel("Laplace T")
+    ax6.set_xlabel("Bayesian T")
+    ax6.set_ylabel("Laplace T")
     ax6.set_title(t_title)
     ax6.grid(True, alpha=0.3)
 
@@ -136,7 +138,8 @@ def get_interface_tensions(tissue, tensions):
     """
     mapping = {}
     for i, (c1, c2) in enumerate(tissue.E_cells):
-        if c1 == 0 or c2 == 0: continue # Skip boundary
+        if c1 == 0 or c2 == 0:
+            continue # Skip boundary
         # Sort to ensure (1,2) is same as (2,1)
         key = tuple(sorted((c1, c2)))
         mapping[key] = tensions[i]
@@ -145,17 +148,20 @@ def get_interface_tensions(tissue, tensions):
 def normalize_z(data):
     """Robust Z-score normalization"""
     valid = data[data != 0]
-    if len(valid) == 0: return data
+    if len(valid) == 0:
+        return data
     std = np.std(valid)
-    if std < 1e-9: return np.zeros_like(data)
+    if std < 1e-9:
+        return np.zeros_like(data)
     return (data - np.mean(valid)) / std
 
 def plot_cells(ax, tissue, values, title):
     ax.imshow(tissue.labels, cmap='gray', alpha=0.3)
     centroids = tissue.C_centroids
 
     # Filter
-    if len(values) > len(centroids): values = values[:len(centroids)]
+    if len(values) > len(centroids):
+        values = values[:len(centroids)]
     valid_idx = np.where(values != 0)[0]
 
     # Robust Scale

examples/compare_methods.py

@@ -1,6 +1,5 @@
 import numpy as np
 import matplotlib.pyplot as plt
-from skimage import io
 import logging
 import os
 
@@ -17,7 +16,8 @@ def run_comparison_demo(img_path='data/test_image.tif'):
     # ---------------------------------------------------------
     print("\n--- Running Bayesian Inference ---")
     tissue_bayes = topology.extract_topology(labels, min_edge_len=4.0, clean=True, trace_pixels=False)
-    if tissue_bayes is None: return
+    if tissue_bayes is None:
+        return
     res_bayes = solvers.solve_bayesian(tissue_bayes, mu=1.0)
 
     # ---------------------------------------------------------
@@ -100,10 +100,12 @@ def run_comparison_demo(img_path='data/test_image.tif'):
 def normalize(data):
     """Returns Z-score. Handles constant data by returning zeros."""
     valid = data[data != 0]
-    if len(valid) == 0: return data
+    if len(valid) == 0:
+        return data
 
     std = np.std(valid)
-    if std < 1e-6: return np.zeros_like(data)
+    if std < 1e-6:
+        return np.zeros_like(data)
 
     return (data - np.mean(valid)) / std
 
@@ -123,9 +125,11 @@ def get_cell_mean_tensions(tissue, edge_tensions):
         if not np.isfinite(val):
             continue
         if c1 > 0: 
-            cell_tensions[c1-1] += val; cell_counts[c1-1] += 1
+            cell_tensions[c1-1] += val
+            cell_counts[c1-1] += 1
         if c2 > 0: 
-            cell_tensions[c2-1] += val; cell_counts[c2-1] += 1
+            cell_tensions[c2-1] += val
+            cell_counts[c2-1] += 1
 
     mask = cell_counts > 0
     cell_tensions[mask] /= cell_counts[mask]
@@ -134,10 +138,10 @@ def get_cell_mean_tensions(tissue, edge_tensions):
 def plot_map(ax, tissue, values, title, cmap='viridis'):
     """Plots cell values. Handles constant values gracefully."""
     ax.imshow(tissue.labels, cmap='gray', alpha=0.3)
-    
     centroids = tissue.C_centroids
-    if len(values) > len(centroids): values = values[:len(centroids)]
-    
+    if len(values) > len(centroids):
+        values = values[:len(centroids)]
+
     # Robust scaling
     if np.ptp(values) < 1e-6: 
         # Constant data (e.g. Laplace Tension)

examples/demo_2d_bayesian.py

@@ -3,7 +3,7 @@
 import os
 import tifffile
 
-from force_inference import segmentation, topology, solvers, visualization
+from force_inference import segmentation, solvers, visualization
 from force_inference.topology_label import extract_topology_label
 
 def run_demo():

examples/demo_laplace.py

@@ -4,7 +4,7 @@
 import numpy as np
 import tifffile
 from force_inference.topology_label import extract_topology_label
-from force_inference import geometry, segmentation, solvers, topology, visualization
+from force_inference import geometry, segmentation, solvers, visualization
 
 
 def _load_membrane_binary(filename):

examples/demo_stress_analysis.py

@@ -1,5 +1,4 @@
 import matplotlib.pyplot as plt
-import numpy as np
 import os
 
 from force_inference import segmentation, topology, solvers, geometry, visualization

examples/diagnose_junctions.py

@@ -7,7 +7,8 @@
 Usage:
     python diagnose_junctions.py --tif test.tif --out /tmp/junc
 """
-import argparse, os
+import argparse
+import os
 import numpy as np
 from PIL import Image
 from skimage import morphology
@@ -26,9 +27,12 @@ def load_tif_2d(path):
     except ImportError:
         arr = np.array(Image.open(path).convert('L'))
     if arr.ndim == 3:
-        if arr.shape[0] <= 4:   arr = arr[0]
-        elif arr.shape[2] <= 4: arr = (0.299*arr[:,:,0]+0.587*arr[:,:,1]+0.114*arr[:,:,2]).astype(arr.dtype)
-        else:                   arr = arr.max(axis=0)
+        if arr.shape[0] <= 4:
+            arr = arr[0]
+        elif arr.shape[2] <= 4:
+            arr = (0.299*arr[:,:,0]+0.587*arr[:,:,1]+0.114*arr[:,:,2]).astype(arr.dtype)
+        else:
+            arr = arr.max(axis=0)
     return arr
 
 
@@ -38,20 +42,23 @@ def skeleton_stats(binary, dilation_r=0):
     if dilation_r > 0:
         mask = morphology.dilation(mask, morphology.disk(dilation_r))
     skel = morphology.skeletonize(mask)
-    kernel = np.ones((3,3), dtype=np.uint8); kernel[1,1] = 0
+    kernel = np.ones((3,3), dtype=np.uint8)
+    kernel[1,1] = 0
     nc = convolve(skel.astype(np.uint8), kernel, mode='constant', cval=0)
     branch_mask = skel & (nc >= 3)
     by, bx = np.where(branch_mask)
     return skel, branch_mask, nc, np.column_stack((bx.astype(float), by.astype(float))) if len(by) else np.zeros((0,2))
 
 
 def cluster(coords, r=4.0):
-    if len(coords) == 0: return coords
+    if len(coords) == 0:
+        return coords
     tree = cKDTree(coords)
     visited = np.zeros(len(coords), dtype=bool)
     out = []
     for i in range(len(coords)):
-        if visited[i]: continue
+        if visited[i]:
+            continue
         nb = tree.query_ball_point(coords[i], r)
         out.append(coords[nb].mean(axis=0))
         visited[nb] = True
@@ -93,7 +100,8 @@ def main():
                  '(red=branch, green=edge, blue=endpoint, yellow=clustered vertex)', fontsize=11)
     plt.tight_layout()
     p = os.path.join(args.out, 'dilation_comparison.png')
-    plt.savefig(p, dpi=130, bbox_inches='tight'); plt.close()
+    plt.savefig(p, dpi=130, bbox_inches='tight')
+    plt.close()
     print(f"Saved: {p}")
 
     # ── Figure 2: zoom into missed junctions (low-branch regions) ────────
@@ -118,7 +126,7 @@ def main():
         top_idx = np.argsort(scores)[::-1][:9]
         top_junctions = ep_clustered[top_idx]
 
-        print(f"\nTop missed junction candidates (by nearby endpoint count):")
+        print("\nTop missed junction candidates (by nearby endpoint count):")
         for i, (cx, cy) in enumerate(top_junctions):
             print(f"  [{i}] center=({cx:.0f},{cy:.0f})  nearby_endpoints={scores[top_idx[i]]}")
 
@@ -139,21 +147,26 @@ def main():
 
             # Overlay dilation=0 skeleton (green)
             crop0 = skel0[y0:y1, x0:x1]
-            ys0, xs0 = np.where(crop0); ax.scatter(xs0, ys0, c='lime', s=2, alpha=0.7)
+            ys0, xs0 = np.where(crop0)
+            ax.scatter(xs0, ys0, c='lime', s=2, alpha=0.7)
 
             # Overlay dilation=1 skeleton (magenta) for comparison
             crop1 = skel1[y0:y1, x0:x1]
-            ys1, xs1 = np.where(crop1); ax.scatter(xs1, ys1, c='magenta', s=2, alpha=0.5)
+            ys1, xs1 = np.where(crop1)
+            ax.scatter(xs1, ys1, c='magenta', s=2, alpha=0.5)
 
             # Branch pixels (dilation=0): red; dilation=1: yellow
-            br0c = bm0[y0:y1, x0:x1]; yb0,xb0 = np.where(br0c)
-            br1c = bm1[y0:y1, x0:x1]; yb1,xb1 = np.where(br1c)
+            br0c = bm0[y0:y1, x0:x1]
+            yb0,xb0 = np.where(br0c)
+            br1c = bm1[y0:y1, x0:x1]
+            yb1,xb1 = np.where(br1c)
             ax.scatter(xb0, yb0, c='red',    s=20, zorder=10)
             ax.scatter(xb1, yb1, c='yellow', s=20, zorder=10, marker='*')
 
             ax.set_title(f'Junction {i}  ({cx},{cy})\n'
                          f'red=branch(d=0)  yellow★=branch(d=1)', fontsize=8)
-            ax.set_xlim(0, x1-x0); ax.set_ylim(y1-y0, 0)
+            ax.set_xlim(0, x1-x0)
+            ax.set_ylim(y1-y0, 0)
             ax.axis('off')
 
         for j in range(n_show, len(axes)):
@@ -168,7 +181,8 @@ def main():
                      'yellow stars = branches recovered by disk(1) dilation', fontsize=11)
         plt.tight_layout()
         p2 = os.path.join(args.out, 'missed_junctions_zoom.png')
-        plt.savefig(p2, dpi=130, bbox_inches='tight'); plt.close()
+        plt.savefig(p2, dpi=130, bbox_inches='tight')
+        plt.close()
         print(f"Saved: {p2}")
 
     # ── Print recommendation ──────────────────────────────────────────────
@@ -179,7 +193,7 @@ def main():
     print(f"\nVertex counts by dilation: {dict(zip(dils, counts))}")
     best = dils[int(np.argmax(counts))]
     print(f"→ Recommended dilation: disk({best})  (maximizes vertex count)")
-    print(f"\nIn topology.py _labels_to_boundary or extract_topology, add:")
+    print("\nIn topology.py _labels_to_boundary or extract_topology, add:")
     print(f"    boundary = morphology.dilation(boundary, morphology.disk({best}))")
 
 

examples/diagnose_tif_vs_jpg.py

@@ -13,7 +13,7 @@
 import numpy as np
 from PIL import Image
 from skimage import morphology
-from scipy.ndimage import convolve, label as nd_label
+from scipy.ndimage import convolve
 from scipy.spatial import cKDTree
 import matplotlib
 matplotlib.use('Agg')
@@ -69,7 +69,8 @@ def labels_to_boundary_thin(labels):
 
 
 def count_branch_points(skel):
-    kernel = np.ones((3, 3), dtype=np.uint8); kernel[1, 1] = 0
+    kernel = np.ones((3, 3), dtype=np.uint8)
+    kernel[1, 1] = 0
     nc = convolve(skel.astype(np.uint8), kernel, mode='constant', cval=0)
     return skel & (nc >= 3), nc
 
@@ -83,7 +84,8 @@ def cluster_count(branch_mask, r=3.0):
     visited = np.zeros(len(coords), dtype=bool)
     n = 0
     for i in range(len(coords)):
-        if visited[i]: continue
+        if visited[i]:
+            continue
         nb = tree.query_ball_point(coords[i], r)
         visited[nb] = True
         n += 1
@@ -111,7 +113,7 @@ def analyze(name, boundary, ax_row):
     ax_row[0].set_title(f'{name}\nboundary ({np.sum(boundary)} px)')
 
     ax_row[1].imshow(disp)
-    ax_row[1].set_title(f'Skeleton\ngreen=edge  red=branch  blue=endpoint')
+    ax_row[1].set_title('Skeleton\ngreen=edge  red=branch  blue=endpoint')
 
     by, bx = np.where(branch_mask)
     ax_row[2].imshow(skel, cmap='gray', alpha=0.4)
@@ -131,17 +133,21 @@ def analyze(name, boundary, ax_row):
     # membrane thickness estimate
     col = boundary[:, boundary.shape[1]//2]
     runs = []
-    in_run = False; run_len = 0
+    in_run = False
+    run_len = 0
     for v in col:
         if v:
-            in_run = True; run_len += 1
+            in_run = True
+            run_len += 1
         elif in_run:
-            runs.append(run_len); in_run = False; run_len = 0
+            runs.append(run_len)
+            in_run = False
+            run_len = 0
     if runs:
         print(f"  membrane thickness (mid-col): "
               f"mean={np.mean(runs):.1f}px  max={max(runs)}px  min={min(runs)}px")
     else:
-        print(f"  membrane thickness: (no runs found in mid column)")
+        print("  membrane thickness: (no runs found in mid column)")
 
     return skel, branch_mask
 

examples/topocheck.py

@@ -1,13 +1,12 @@
 import matplotlib.pyplot as plt
-import matplotlib.image as mpimg
 import os
 import logging
 import numpy as np
 from matplotlib.patches import Polygon
 from matplotlib.collections import PatchCollection
 import tifffile
 
-from force_inference import segmentation, topology, visualization
+from force_inference import segmentation, topology
 
 logging.basicConfig(level=logging.INFO)
 

examples/verify_correction.py

@@ -40,7 +40,8 @@ def plot_map(ax, tissue, values, title):
 
     # Normalize for view
     val_disp = values[values!=0]
-    if len(val_disp)==0: return
+    if len(val_disp)==0:
+        return
     v_min, v_max = np.percentile(val_disp, [2, 98])
 
     sc = ax.scatter(cents[:,0], cents[:,1], c=values[:len(cents)], 

force_inference/core.py

@@ -1,5 +1,5 @@
 import numpy as np
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import List, Optional
 
 @dataclass