py-TranspaceR 0.1.0__py3-none-any.whl

transspacer/plotting.py

@@ -0,0 +1,199 @@
+"""Plotting functions: spatial visualization, heatmaps, UMAP, etc."""
+
+import numpy as np
+
+try:
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    import matplotlib.colors as mcolors
+    HAS_MPL = True
+except ImportError:
+    HAS_MPL = False
+
+
+def plot_fov(x, y, cluster_labels, output_path=None, title="FoV"):
+    """Scatter plot of cell centroids colored by cluster.
+
+    Parameters
+    ----------
+    x, y : np.ndarray
+        Cell coordinates.
+    cluster_labels : array-like
+        Cluster labels.
+    output_path : str, optional
+        Save path.
+    title : str
+        Plot title.
+    """
+    if not HAS_MPL:
+        return
+    fig, ax = plt.subplots(figsize=(8, 8))
+    unique_labels = np.unique(cluster_labels)
+    cmap = plt.cm.get_cmap("tab20", len(unique_labels))
+    for i, label in enumerate(unique_labels):
+        mask = cluster_labels == label
+        ax.scatter(x[mask], y[mask], s=1, c=[cmap(i)], label=str(label), alpha=0.7)
+    ax.set_title(title)
+    ax.set_aspect("equal")
+    ax.invert_yaxis()
+    if output_path:
+        fig.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+
+
+def plot_fov_gene(x, y, expression_values, gene_name, output_path=None):
+    """Scatter plot colored by gene expression (white-yellow-orange-red)."""
+    if not HAS_MPL:
+        return
+    from .utils import color_convertion
+    colors = color_convertion(expression_values)
+    fig, ax = plt.subplots(figsize=(8, 8))
+    ax.scatter(x, y, s=1, c=colors, alpha=0.7)
+    ax.set_title(gene_name)
+    ax.set_aspect("equal")
+    ax.invert_yaxis()
+    if output_path:
+        fig.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+
+
+def plot_variogram(sill, range_val, alpha, nugget, model, r_data, v_data, r2, output_path=None):
+    """Plot fitted variogram curve over data points."""
+    if not HAS_MPL:
+        return
+    fig, ax = plt.subplots(figsize=(8, 6))
+    ax.scatter(r_data, v_data, s=10, alpha=0.5, label="Data")
+
+    r_fit = np.linspace(0, max(r_data) * 1.1, 100)
+    if model == "Constant":
+        ax.axhline(sill, color="red", label=f"Constant (C={sill:.3f})")
+    elif model == "Exponential":
+        v_fit = sill * (1 - np.exp(-r_fit / range_val)) + nugget
+        ax.plot(r_fit, v_fit, "r-", label=f"Exp (C={sill:.3f}, tau={range_val:.3f})")
+    elif model == "Finetuned exponential":
+        v_fit = sill * (1 - np.exp(-r_fit**alpha / range_val)) + nugget
+        ax.plot(r_fit, v_fit, "r-", label=f"FineExp (alpha={alpha:.3f})")
+
+    ax.set_xlabel("Distance")
+    ax.set_ylabel("Variogram")
+    ax.set_title(f"R2={r2:.3f}, Model={model}")
+    ax.legend()
+    if output_path:
+        fig.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+
+
+def save_umap(umap_coords, labels, output_path, title="UMAP"):
+    """Save UMAP scatter plot."""
+    if not HAS_MPL:
+        return
+    fig, ax = plt.subplots(figsize=(8, 8))
+    unique = np.unique(labels)
+    cmap = plt.cm.get_cmap("tab20", len(unique))
+    for i, l in enumerate(unique):
+        mask = labels == l
+        ax.scatter(umap_coords[mask, 0], umap_coords[mask, 1], s=1, c=[cmap(i)], label=str(l), alpha=0.5)
+    ax.set_title(title)
+    ax.legend(markerscale=10, fontsize=6)
+    fig.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+
+
+def save_heatmap_markers(expression, gene_names, cluster_labels, output_path,
+                          top_n: int = 5):
+    """Save marker gene heatmap per cluster."""
+    if not HAS_MPL:
+        return
+    groups = np.unique(cluster_labels)
+    markers = []
+    for g in groups:
+        mask = cluster_labels == g
+        means_in = expression[mask, :].mean(axis=0)
+        means_out = expression[~mask, :].mean(axis=0) if np.any(~mask) else np.zeros_like(means_in)
+        fc = means_in - means_out
+        top_idx = np.argsort(-fc)[:top_n]
+        markers.extend(top_idx.tolist())
+    markers = sorted(set(markers))
+
+    fig, ax = plt.subplots(figsize=(12, 8))
+    data = expression[:, markers]
+    im = ax.imshow(data, aspect="auto", cmap="viridis")
+    ax.set_yticks(range(len(groups)))
+    ax.set_yticklabels(groups)
+    plt.colorbar(im)
+    fig.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+
+
+def save_annotation_plot(cluster_labels, cell_types, output_path):
+    """Bar plot of cell type proportions per cluster."""
+    if not HAS_MPL:
+        return
+    import pandas as pd
+    df = pd.DataFrame({"cluster": cluster_labels, "type": cell_types})
+    ct = pd.crosstab(df["cluster"], df["type"], normalize="index")
+    fig, ax = plt.subplots(figsize=(10, 6))
+    ct.plot(kind="bar", stacked=True, ax=ax)
+    ax.set_ylabel("Proportion")
+    ax.legend(bbox_to_anchor=(1.05, 1), loc="upper left", fontsize=6)
+    fig.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+
+
+def save_boxplot(expression, gene_idx, gene_name, cluster_labels, output_path):
+    """Gene expression boxplot by cluster."""
+    if not HAS_MPL:
+        return
+    groups = np.unique(cluster_labels)
+    data = [expression[cluster_labels == g, gene_idx] for g in groups]
+    fig, ax = plt.subplots(figsize=(8, 6))
+    ax.boxplot(data, labels=groups)
+    ax.set_title(gene_name)
+    ax.set_ylabel("Expression")
+    fig.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+
+
+def save_dendogram(data, labels, output_path):
+    """Hierarchical clustering dendrogram."""
+    if not HAS_MPL:
+        return
+    from scipy.cluster.hierarchy import linkage, dendrogram
+    Z = linkage(data, method="ward")
+    fig, ax = plt.subplots(figsize=(12, 6))
+    dendrogram(Z, labels=labels, ax=ax, leaf_rotation=90, leaf_font_size=6)
+    fig.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+
+
+def save_geary_variance_plot(geary_values, variance_values, selected_mask,
+                              output_path, title="Geary vs Variance"):
+    """Scatter of variance vs Geary score."""
+    if not HAS_MPL:
+        return
+    fig, ax = plt.subplots(figsize=(8, 6))
+    ax.scatter(geary_values, variance_values, s=5, alpha=0.3, c="black")
+    if selected_mask is not None and np.any(selected_mask):
+        ax.scatter(geary_values[selected_mask], variance_values[selected_mask],
+                   s=10, c="red", label="Selected")
+    ax.set_xlabel("Geary Score")
+    ax.set_ylabel("Variance")
+    ax.set_title(title)
+    ax.legend()
+    fig.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+
+
+def save_tissue_visualization(x, y, values, output_path, title="Tissue"):
+    """Spatial tissue visualization."""
+    if not HAS_MPL:
+        return
+    fig, ax = plt.subplots(figsize=(8, 8))
+    sc = ax.scatter(x, y, s=1, c=values, cmap="viridis", alpha=0.7)
+    plt.colorbar(sc)
+    ax.set_title(title)
+    ax.set_aspect("equal")
+    ax.invert_yaxis()
+    fig.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)

transspacer/qc.py

@@ -0,0 +1,74 @@
+"""Quality control: Otsu thresholding and QC gene/RNA thresholds."""
+
+import numpy as np
+
+
+def otsu_thresholding(x: np.ndarray, number_bins: int = 100) -> float:
+    """Otsu's method to find optimal threshold minimizing intra-class variance.
+
+    Parameters
+    ----------
+    x : np.ndarray
+        1D data vector.
+    number_bins : int
+        Number of quantile-based bins.
+
+    Returns
+    -------
+    float
+        Selected threshold value.
+    """
+    list_bin = np.quantile(x, np.linspace(0, 1, number_bins))
+    intra_variance = np.empty(number_bins)
+    for k in range(number_bins):
+        threshold = list_bin[k]
+        below = x[x < threshold]
+        above = x[x > threshold]
+        s = 0.0
+        if len(below) > 1:
+            s += len(below) * np.var(below, ddof=1)
+        if len(above) > 1:
+            s += len(above) * np.var(above, ddof=1)
+        intra_variance[k] = s
+    return list_bin[np.argmin(intra_variance)]
+
+
+def qc_gene_threshold(expression, meta_data_radius, gene_names):
+    """QC gene threshold using Otsu on log10 gene counts.
+
+    Parameters
+    ----------
+    expression : sparse or dense matrix
+        Gene expression (cells x genes).
+    meta_data_radius : np.ndarray
+        Cell radii.
+    gene_names : list of str
+        Gene names.
+
+    Returns
+    -------
+    dict
+        Otsu_threshold, Separability_score.
+    """
+    from scipy.sparse import issparse
+
+    if issparse(expression):
+        gene_size = np.array(expression.sum(axis=0)).flatten()
+    else:
+        gene_size = expression.sum(axis=0)
+
+    neg_mask = np.array([
+        any(pat in str(g) for pat in ["Neg", "False", "Blank"])
+        for g in gene_names
+    ])
+    neg_counts = np.log10(gene_size[neg_mask])
+    neg_counts = neg_counts[np.isfinite(neg_counts)]
+
+    x = np.log10(gene_size)
+    x = x[np.isfinite(x)]
+
+    threshold = otsu_thresholding(x)
+    neg_before = np.sum(neg_counts < threshold)
+    score = neg_before / len(neg_counts) if len(neg_counts) > 0 else 0.0
+
+    return {"Otsu_threshold": 10**threshold, "Separability_score": score}

transspacer/sparse_utils.py

@@ -0,0 +1,67 @@
+"""Sparse matrix utilities: column variance, group-wise aggregation."""
+
+import numpy as np
+from scipy.sparse import issparse, csc_matrix
+
+
+def colvars_sparse(mat) -> np.ndarray:
+    """Column variance of a sparse matrix (CSC format).
+
+    Parameters
+    ----------
+    mat : scipy.sparse.csc_matrix or np.ndarray
+        Input matrix.
+
+    Returns
+    -------
+    np.ndarray
+        Variance of each column.
+    """
+    if issparse(mat):
+        mat = csc_matrix(mat)
+        n_cells = mat.shape[0]
+        means = np.array(mat.mean(axis=0)).flatten()
+        variances = np.zeros(mat.shape[1])
+        for j in range(mat.shape[1]):
+            start = mat.indptr[j]
+            end = mat.indptr[j + 1]
+            if start < end:
+                diff_sq = (mat.data[start:end] - means[j]) ** 2
+                sum_sq = np.sum(diff_sq)
+            else:
+                sum_sq = 0.0
+            variances[j] = (sum_sq + (n_cells - (end - start)) * means[j] ** 2) / n_cells
+        return variances
+    else:
+        return np.var(mat, axis=0)
+
+
+def aggregate_sparse(expression, grouping) -> np.ndarray:
+    """Group-wise column means on a matrix.
+
+    Parameters
+    ----------
+    expression : sparse or dense matrix
+        Expression matrix (cells x genes).
+    grouping : array-like
+        Cluster/group labels per cell.
+
+    Returns
+    -------
+    np.ndarray
+        Mean expression per group (genes x groups), matching R's sapply output.
+    """
+    groups = np.unique(grouping)
+    if issparse(expression):
+        result = np.zeros((expression.shape[1], len(groups)))
+        for i, g in enumerate(groups):
+            idx = np.where(grouping == g)[0]
+            if len(idx) > 0:
+                result[:, i] = np.array(expression[idx, :].mean(axis=0)).flatten()
+    else:
+        result = np.zeros((expression.shape[1], len(groups)))
+        for i, g in enumerate(groups):
+            idx = np.where(grouping == g)[0]
+            if len(idx) > 0:
+                result[:, i] = expression[idx, :].mean(axis=0)
+    return result

transspacer/spatial_stats.py

@@ -0,0 +1,325 @@
+"""Spatial statistics: Geary's C, excess variance ratio, excess zero score."""
+
+import numpy as np
+from scipy.sparse import issparse, csc_matrix
+from scipy.spatial import Delaunay
+from scipy.sparse.csgraph import connected_components
+from scipy.stats import norm, kurtosis as scipy_kurtosis
+from scipy.optimize import curve_fit
+from scipy.stats import pearsonr
+
+
+def _build_spatial_weight_matrix(coords: np.ndarray):
+    """Build spatial weight matrix from Delaunay triangulation."""
+    from scipy.sparse import lil_matrix
+
+    tri = Delaunay(coords)
+    n = len(coords)
+    W = lil_matrix((n, n), dtype=float)
+
+    # Extract edges from simplices
+    edges = set()
+    for simplex in tri.simplices:
+        for i in range(3):
+            for j in range(i + 1, 3):
+                edge = (min(simplex[i], simplex[j]), max(simplex[i], simplex[j]))
+                edges.add(edge)
+
+    for i, j in edges:
+        W[i, j] = 1.0
+        W[j, i] = 1.0
+
+    W = csc_matrix(W)
+    # Normalize: W[i,j] = 1/degree for neighbors
+    row_sums = np.array(W.sum(axis=1)).flatten()
+    row_sums[row_sums == 0] = 1
+    # Symmetric normalization
+    W = W + W.T
+    W.data = np.ones_like(W.data)  # binary adjacency
+    return csc_matrix(W)
+
+
+def geary_c_score(expression: np.ndarray, coords: np.ndarray,
+                  pvalue_threshold: float = 0.01) -> dict:
+    """Compute Geary's C score for each gene.
+
+    Parameters
+    ----------
+    expression : np.ndarray
+        Expression matrix (cells x genes).
+    coords : np.ndarray
+        Spatial coordinates (cells x 2).
+    pvalue_threshold : float
+        FDR-adjusted p-value threshold for gene selection.
+
+    Returns
+    -------
+    dict
+        Values (1/C), Selected_genes, P_values.
+    """
+    n_cells, n_genes = expression.shape
+
+    # Build Delaunay-based spatial weight matrix
+    W = _build_spatial_weight_matrix(coords)
+    W_dense = W.toarray()
+
+    S_0 = W_dense.sum()
+    S_1 = 0.5 * np.sum((W_dense + W_dense.T) ** 2)
+    x_sum = W_dense.sum(axis=0)
+    y_sum = W_dense.sum(axis=1)
+    S_2 = np.sum((x_sum + y_sum) ** 2)
+    N = n_cells
+    W_sum = W_dense.sum()
+
+    geary_values = np.zeros(n_genes)
+    p_values = np.zeros(n_genes)
+
+    for i in range(n_genes):
+        X = expression[:, i].reshape(-1, 1)
+        X_sq = X ** 2
+
+        product_1 = 2 * np.sum(W_dense @ X_sq)
+        product_2 = 2 * float((X.T @ W_dense @ X).item())
+        var_X = np.var(X, ddof=1) * N
+
+        if var_X == 0:
+            geary_values[i] = 1.0
+            p_values[i] = 1.0
+            continue
+
+        geary_c = (N - 1) * (product_1 - product_2) / (2 * var_X * W_sum)
+        geary_values[i] = geary_c
+
+        # Kurtosis for variance under randomness
+        b_2 = scipy_kurtosis(expression[:, i], fisher=False)
+
+        var_random = (
+            (N - 1) * S_1 * (N**2 - 3*N + 3 - (N-1)*b_2)
+            - 0.25 * (N - 1) * S_2 * (N**2 + 3*N - 6 - (N**2 - N + 2)*b_2)
+            + S_0**2 * (N**2 - 3 - (N-1)**2 * b_2)
+        ) / (N * (N-2) * (N-3) * S_0**2)
+
+        p_values[i] = norm.cdf(geary_c, loc=1, scale=np.sqrt(max(var_random, 1e-300)))
+
+    # Invert C (higher = more spatial)
+    inv_geary = 1.0 / geary_values
+    inv_geary[~np.isfinite(inv_geary)] = 0
+
+    # FDR correction (Benjamini-Hochberg)
+    from statsmodels.stats.multitest import multipletests
+    try:
+        _, adj_p, _, _ = multipletests(p_values, method="fdr_bh")
+    except ImportError:
+        # Simple BH fallback
+        order = np.argsort(p_values)
+        ranked = np.arange(1, len(p_values) + 1)
+        adj_p = np.zeros_like(p_values)
+        adj_p[order] = p_values[order] * len(p_values) / ranked
+        adj_p = np.minimum(adj_p, 1.0)
+        # Enforce monotonicity
+        for i in range(len(adj_p) - 2, -1, -1):
+            adj_p[order[i]] = min(adj_p[order[i]], adj_p[order[i + 1]])
+
+    # Sort by geary score descending
+    sort_idx = np.argsort(-inv_geary)
+    inv_geary_sorted = inv_geary[sort_idx]
+    adj_p_sorted = adj_p[sort_idx]
+
+    selected_mask = adj_p_sorted <= pvalue_threshold
+    selected_genes = np.where(selected_mask)[0].tolist()
+
+    # Clip extreme p-values
+    adj_p_clipped = adj_p.copy()
+    adj_p_clipped[adj_p_clipped < 1e-300] = 1e-300
+
+    return {
+        "Values": inv_geary_sorted,
+        "Selected_genes": selected_genes,
+        "P_values": adj_p_clipped,
+        "sort_idx": sort_idx
+    }
+
+
+def excess_variance_ratio_nb(expression: np.ndarray,
+                              p_value_threshold: float = 0.01,
+                              ratio_threshold: float = 1.5) -> dict:
+    """Excess variance ratio using Negative Binomial model.
+
+    Parameters
+    ----------
+    expression : np.ndarray
+        Expression matrix (cells x genes).
+    p_value_threshold : float
+        P-value threshold for significance.
+    ratio_threshold : float
+        Variance ratio threshold.
+
+    Returns
+    -------
+    dict
+        Selected_genes, Excess_variance_ratio.
+    """
+    if issparse(expression):
+        mean_expr = np.array(expression.mean(axis=0)).flatten()
+        var_gene = np.array([
+            np.var(expression[:, j].toarray().flatten(), ddof=1)
+            if issparse(expression) else np.var(expression[:, j], ddof=1)
+            for j in range(expression.shape[1])
+        ])
+    else:
+        mean_expr = np.mean(expression, axis=0)
+        var_gene = np.var(expression, axis=0, ddof=1)
+
+    mean_sq = mean_expr ** 2
+
+    # Fit NB null model: var ~ mu + mu^2 (forced through origin)
+    # var = s * mu^2 + mu => var - mu = s * mu^2
+    valid = mean_sq > 0
+    y_fit = var_gene[valid] - mean_expr[valid]
+    X_fit = mean_sq[valid].reshape(-1, 1)
+
+    # Simple OLS: y = s * X
+    s_est = float(np.sum(y_fit * X_fit.flatten()) / np.sum(X_fit.flatten() ** 2))
+    s_est = max(s_est, 1e-10)
+
+    fitted_var = mean_expr + s_est * mean_sq
+    excess_ratio = var_gene / fitted_var
+    excess_ratio[~np.isfinite(excess_ratio)] = 0
+
+    # Monte Carlo significance
+    n_cells = expression.shape[0]
+    n_sim = 500
+    mu_values = np.quantile(mean_expr, np.linspace(0, 1, 30))
+
+    # Estimate variance-of-variance at each mu
+    table_var = np.zeros(len(mu_values))
+    for idx, mu in enumerate(mu_values):
+        sims_var = np.zeros(n_sim)
+        for s in range(n_sim):
+            # NB: size = 1/s, mu = mu
+            samples = np.random.negative_binomial(1 / s_est, 1 / s_est / (mu + 1 / s_est), size=n_cells)
+            sims_var[s] = np.var(samples, ddof=1)
+        table_var[idx] = np.var(sims_var)
+
+    # Interpolate
+    log_mu = np.log10(mu_values + 1e-300)
+    log_var = np.log10(table_var + 1e-300)
+    est_var = 10 ** np.interp(np.log10(mean_expr + 1e-300), log_mu, log_var)
+
+    p_vals = 1 - norm.cdf(var_gene, loc=fitted_var, scale=np.sqrt(est_var))
+
+    # BH FDR
+    from statsmodels.stats.multitest import multipletests
+    try:
+        _, adj_p, _, _ = multipletests(p_vals, method="fdr_bh")
+    except ImportError:
+        order = np.argsort(p_vals)
+        ranked = np.arange(1, len(p_vals) + 1)
+        adj_p = np.zeros_like(p_vals)
+        adj_p[order] = p_vals[order] * len(p_vals) / ranked
+        adj_p = np.minimum(adj_p, 1.0)
+
+    selected = np.where((adj_p < p_value_threshold) & (excess_ratio > ratio_threshold))[0]
+
+    return {
+        "Selected_genes": selected.tolist(),
+        "Excess_variance_ratio": excess_ratio
+    }
+
+
+def excess_zero_score_nb(expression: np.ndarray,
+                         p_value_threshold: float = 0.01,
+                         delta_threshold: float = 0.01) -> dict:
+    """Excess zero score using Negative Binomial model.
+
+    Parameters
+    ----------
+    expression : np.ndarray
+        Expression matrix (cells x genes).
+    p_value_threshold : float
+        P-value threshold.
+    delta_threshold : float
+        Excess zero score threshold.
+
+    Returns
+    -------
+    dict
+        Selected_genes, Excess_zero_score.
+    """
+    n_cells = expression.shape[0]
+
+    if issparse(expression):
+        mean_expr = np.array(expression.mean(axis=0)).flatten()
+        total_expr = np.array(expression.sum(axis=0)).flatten()
+        prop_zero = np.array((expression == 0).sum(axis=0)).flatten() / n_cells
+        # Variance via colvars_sparse
+        from .sparse_utils import colvars_sparse
+        var_expr = colvars_sparse(expression)
+    else:
+        mean_expr = np.mean(expression, axis=0)
+        total_expr = np.sum(expression, axis=0)
+        prop_zero = np.mean(expression == 0, axis=0)
+        var_expr = np.var(expression, axis=0, ddof=1)
+
+    # Fit NB model for expected zero proportion
+    # theta_init = median(1/((var-mean)/mean^2))
+    with np.errstate(divide="ignore", invalid="ignore"):
+        theta_raw = (var_expr - mean_expr) / mean_expr ** 2
+    theta_raw = theta_raw[theta_raw > 0]
+    theta_init = np.median(theta_raw) if len(theta_raw) > 0 else 1.0
+
+    # Fit: log(prop_zero) ~ theta*log(theta) - theta*log(theta+mean)
+    valid = (prop_zero > 0) & (prop_zero < 1) & (mean_expr > 0)
+    if np.sum(valid) < 3:
+        return {"Selected_genes": [], "Excess_zero_score": np.zeros(expression.shape[1])}
+
+    log_prop = np.log(prop_zero[valid])
+    mu_v = mean_expr[valid]
+
+    def nb_zero_model(mu, theta):
+        return theta * np.log(theta) - theta * np.log(theta + mu)
+
+    try:
+        popt, _ = curve_fit(nb_zero_model, mu_v, log_prop, p0=[theta_init],
+                            bounds=([1e-10], [np.inf]), method="trf")
+        theta = popt[0]
+    except Exception:
+        theta = theta_init
+
+    expected_prop_zero = (theta / (theta + mean_expr)) ** theta
+    delta = prop_zero - expected_prop_zero
+
+    # Monte Carlo for variance estimation
+    n_sim = 500
+    mu_values = np.quantile(mean_expr, np.linspace(0, 1, 30))
+
+    table_var = np.zeros(len(mu_values))
+    for idx, mu in enumerate(mu_values):
+        sims_pz = np.zeros(n_sim)
+        for s in range(n_sim):
+            samples = np.random.negative_binomial(1 / theta, 1 / theta / (mu + 1 / theta), size=n_cells)
+            sims_pz[s] = np.mean(samples == 0)
+        table_var[idx] = np.var(sims_pz)
+
+    log_mu = np.log10(mu_values + 1e-300)
+    log_var = np.log10(table_var + 1e-300)
+    est_var = 10 ** np.interp(np.log10(mean_expr + 1e-300), log_mu, log_var)
+
+    p_vals = 1 - norm.cdf(prop_zero, loc=expected_prop_zero, scale=np.sqrt(est_var))
+
+    from statsmodels.stats.multitest import multipletests
+    try:
+        _, adj_p, _, _ = multipletests(p_vals, method="fdr_bh")
+    except ImportError:
+        order = np.argsort(p_vals)
+        ranked = np.arange(1, len(p_vals) + 1)
+        adj_p = np.zeros_like(p_vals)
+        adj_p[order] = p_vals[order] * len(p_vals) / ranked
+        adj_p = np.minimum(adj_p, 1.0)
+
+    selected = np.where((adj_p < p_value_threshold) & (delta > delta_threshold))[0]
+
+    return {
+        "Selected_genes": selected.tolist(),
+        "Excess_zero_score": delta
+    }