mcDETECT 1.0.12__py3-none-any.whl → 2.0.1__py3-none-any.whl

mcDETECT/__init__.py

@@ -1,2 +1,3 @@
-__version__ = "1.0.12"
-from .model import closest, mcDETECT
+__version__ = "2.0.1"
+from .utils import *
+from .model import mcDETECT, spot_neuron, spot_granule, neighbor_granule, neuron_embedding_one_hot, neuron_embedding_spatial_weight

mcDETECT/model.py

@@ -9,34 +9,9 @@ from scipy.spatial import cKDTree
 from scipy.stats import poisson
 from shapely.geometry import Point
 from sklearn.cluster import DBSCAN
+from sklearn.preprocessing import OneHotEncoder
 
-
-def closest(lst, K):
-    return lst[min(range(len(lst)), key = lambda i: abs(lst[i] - K))]
-
-
-def make_tree(d1 = None, d2 = None, d3 = None):
-    active_dimensions = [dimension for dimension in [d1, d2, d3] if dimension is not None]
-    if len(active_dimensions) == 1:
-        points = np.c_[active_dimensions[0].ravel()]
-    elif len(active_dimensions) == 2:
-        points = np.c_[active_dimensions[0].ravel(), active_dimensions[1].ravel()]
-    elif len(active_dimensions) == 3:
-        points = np.c_[active_dimensions[0].ravel(), active_dimensions[1].ravel(), active_dimensions[2].ravel()]
-    return cKDTree(points)
-
-
-def make_rtree(spheres):
-    p = index.Property()
-    idx = index.Index(properties = p)
-    for i, sphere in enumerate(spheres.itertuples()):
-        center = Point(sphere.sphere_x, sphere.sphere_y)
-        bounds = (center.x - sphere.sphere_r,
-                  center.y - sphere.sphere_r,
-                  center.x + sphere.sphere_r,
-                  center.y + sphere.sphere_r)
-        idx.insert(i, bounds)
-    return idx
+from .utils import *
 
 
 class mcDETECT:
@@ -100,7 +75,7 @@ class mcDETECT:
     def dbscan(self, target_names = None, write_csv = False, write_path = "./"):
         
         if self.type != "Xenium":
-            z_grid = list(np.unique(self.transcripts["global_z"]))
+            z_grid = list(self.transcripts["global_z"].unique())
             z_grid.sort()
         
         if target_names is None:
@@ -148,7 +123,7 @@ class mcDETECT:
                 other_trans = others.iloc[other_idx]
                 other_in_nucleus = np.sum(other_trans["overlaps_nucleus"])
                 other_size = other_trans.shape[0]
-                other_comp = len(np.unique(other_trans["target"]))
+                other_comp = len(other_trans["target"].unique())
                 total_size = temp_size + other_size
                 total_comp = 1 + other_comp
                 local_score = (temp_in_nucleus + other_in_nucleus) / total_size
@@ -324,7 +299,7 @@ class mcDETECT:
     def profile(self, synapse, genes = None, print_itr = False):
         
         if genes is None:
-            genes = list(np.unique(self.transcripts["target"]))
+            genes = list(self.transcripts["target"].unique())
             transcripts = self.transcripts
         else:
             transcripts = self.transcripts[self.transcripts["target"].isin(genes)]
@@ -357,7 +332,7 @@ class mcDETECT:
     def spot_expression(self, grid_len, genes = None):
         
         if genes is None:
-            genes = list(np.unique(self.transcripts["target"]))
+            genes = list(self.transcripts["target"].unique())
             transcripts = self.transcripts
         else:
             transcripts = self.transcripts[self.transcripts["target"].isin(genes)]
@@ -401,35 +376,226 @@ class mcDETECT:
         adata.var_keys = genes
         return adata
     
+
+# [MAIN] anndata, spot-level neuron metadata
+def spot_neuron(adata_neuron, spot, grid_len = 50, neuron_loc_key = ["global_x", "global_y"], spot_loc_key = ["global_x", "global_y"]):
+    
+    adata_neuron = adata_neuron.copy()
+    neurons = adata_neuron.obs
+    spot = spot.copy()
+    
+    half_len = grid_len / 2
     
-    # [MAIN] anndata, spot-level synapse metadata
-    def spot_synapse(self, synapse, spot):
+    indicator, neuron_count = [], []
+    
+    for _, row in spot.obs.iterrows():
         
-        x_grid, y_grid = list(np.unique(spot.obs["global_x"])), list(np.unique(spot.obs["global_y"]))
-        diameter = x_grid[1] - x_grid[0]
+        x = row[spot_loc_key[0]]
+        y = row[spot_loc_key[1]]
+        neuron_temp = neurons[(neurons[neuron_loc_key[0]] > x - half_len) & (neurons[neuron_loc_key[0]] < x + half_len) & (neurons[neuron_loc_key[1]] > y - half_len) & (neurons[neuron_loc_key[1]] < y + half_len)]
+        indicator.append(int(len(neuron_temp) > 0))
+        neuron_count.append(len(neuron_temp))
+    
+    spot.obs["indicator"] = indicator
+    spot.obs["neuron_count"] = neuron_count
+    return spot
+
+    
+# [MAIN] anndata, spot-level granule metadata
+def spot_granule(granule, spot, grid_len = 50, gnl_loc_key = ["sphere_x", "sphere_y"], spot_loc_key = ["global_x", "global_y"]):
+    
+    granule = granule.copy()
+    spot = spot.copy()
+    
+    half_len = grid_len / 2
+
+    indicator, granule_count, granule_radius, granule_size, granule_score = [], [], [], [], []
+    
+    for _, row in spot.obs.iterrows():
         
-        indicator, synapse_count, synapse_radius, synapse_size, synapse_score = [], [], [], [], []
-        for i in x_grid:
-            x_min_temp = i
-            x_max_temp = i + diameter
-            for j in y_grid:
-                y_min_temp = j
-                y_max_temp = j + diameter
-                syn_temp = synapse[(synapse["sphere_x"] > x_min_temp) & (synapse["sphere_x"] < x_max_temp) & (synapse["sphere_y"] > y_min_temp) & (synapse["sphere_y"] < y_max_temp)]
-                indicator.append(int(syn_temp.shape[0] > 0))
-                synapse_count.append(syn_temp.shape[0])
-                if syn_temp.shape[0] == 0:
-                    synapse_radius.append(0)
-                    synapse_size.append(0)
-                    synapse_score.append(0)
-                else:
-                    synapse_radius.append(np.nanmean(syn_temp["sphere_r"]))
-                    synapse_size.append(np.nanmean(syn_temp["size"]))
-                    synapse_score.append(np.nanmean(syn_temp["in_nucleus"]))
+        x = row[spot_loc_key[0]]
+        y = row[spot_loc_key[1]]
+        gnl_temp = granule[(granule[gnl_loc_key[0]] >= x - half_len) & (granule[gnl_loc_key[0]] < x + half_len) & (granule[gnl_loc_key[1]] >= y - half_len) & (granule[gnl_loc_key[1]] < y + half_len)]
+        indicator.append(int(len(gnl_temp) > 0))
+        granule_count.append(len(gnl_temp))
+
+        if len(gnl_temp) == 0:
+            granule_radius.append(0)
+            granule_size.append(0)
+            granule_score.append(0)
+        else:
+            granule_radius.append(np.nanmean(gnl_temp["sphere_r"]))
+            granule_size.append(np.nanmean(gnl_temp["size"]))
+            granule_score.append(np.nanmean(gnl_temp["in_nucleus"]))
+    
+    spot.obs["indicator"] = indicator
+    spot.obs["gnl_count"] = granule_count
+    spot.obs["gnl_radius"] = granule_radius
+    spot.obs["gnl_size"] = granule_size
+    spot.obs["gnl_score"] = granule_score
+    return spot
+
+
+# [Main] anndata, neuron-granule colocalization
+def neighbor_granule(adata_neuron, granule_adata, radius = 10, sigma = None, loc_key = ["global_x", "global_y"]):
+    
+    adata_neuron = adata_neuron.copy()
+    granule_adata = granule_adata.copy()
+    
+    if sigma is None:
+        sigma = radius / 2
+    
+    # neuron and granule coordinates
+    neuron_coords = adata_neuron.obs[loc_key].values
+    gnl_coords = granule_adata.obs[loc_key].values
+    
+    # make tree
+    tree = make_tree(d1 = gnl_coords[:, 0], d2 = gnl_coords[:, 1])
+    
+    # query neighboring granules for each neuron
+    neighbor_indices = tree.query_ball_point(neuron_coords, r = radius)
+    
+    # record count and indices
+    granule_counts = np.array([len(indices) for indices in neighbor_indices])
+    adata_neuron.obs["neighbor_gnl_count"] = granule_counts
+    adata_neuron.uns["neighbor_gnl_indices"] = neighbor_indices
+    
+    # ---------- neighboring granule expression matrix ---------- #
+    n_neurons, n_genes = adata_neuron.n_obs, adata_neuron.n_vars
+    weighted_expr = np.zeros((n_neurons, n_genes))
+    
+    for i, indices in enumerate(neighbor_indices):
+        if len(indices) == 0:
+            continue
+        distances = np.linalg.norm(gnl_coords[indices] - neuron_coords[i], axis = 1)
+        weights = np.exp(- (distances ** 2) / (2 * sigma ** 2))
+        weights = weights / weights.sum()
+        weighted_expr[i] = np.average(granule_adata.X[indices], axis = 0, weights = weights)
+
+    adata_neuron.obsm["weighted_gnl_expression"] = weighted_expr
+    
+    # ---------- neighboring granule spatial feature ---------- #
+    features = []
+
+    for i, gnl_idx in enumerate(neighbor_indices):
         
-        spot.obs["indicator"] = indicator
-        spot.obs["syn_count"] = synapse_count
-        spot.obs["syn_radius"] = synapse_radius
-        spot.obs["syn_size"] = synapse_size
-        spot.obs["syn_score"] = synapse_score
-        return spot
+        feats = {}
+        feats["n_granules"] = len(gnl_idx)
+
+        if len(gnl_idx) == 0:
+            feats.update({"mean_distance": np.nan, "std_distance": np.nan, "radius_max": np.nan, "radius_min": np.nan, "density": 0, "center_offset_norm": np.nan, "anisotropy_ratio": np.nan})
+        else:
+            gnl_pos = gnl_coords[gnl_idx]
+            neuron_pos = neuron_coords[i]
+            dists = np.linalg.norm(gnl_pos - neuron_pos, axis = 1)
+            feats["mean_distance"] = dists.mean()
+            feats["std_distance"] = dists.std()
+            feats["radius_max"] = dists.max()
+            feats["radius_min"] = dists.min()
+            feats["density"] = len(gnl_idx) / (np.pi * radius ** 2)
+            centroid = gnl_pos.mean(axis = 0)
+            offset = centroid - neuron_pos
+            feats["center_offset_norm"] = np.linalg.norm(offset)
+            cov = np.cov((gnl_pos - neuron_pos).T)
+            eigvals = np.linalg.eigvalsh(cov)
+            if np.min(eigvals) > 0:
+                feats["anisotropy_ratio"] = np.max(eigvals) / np.min(eigvals)
+            else:
+                feats["anisotropy_ratio"] = np.nan
+
+        features.append(feats)
+    
+    spatial_df = pd.DataFrame(features, index = adata_neuron.obs_names)
+    return adata_neuron, spatial_df
+
+
+# [MAIN] numpy array, neuron embeddings based on neighboring granules
+def neuron_embedding_one_hot(adata_neuron, granule_adata, k = 10, radius = 10, loc_key = ["global_x", "global_y"], gnl_subtype_key = "granule_subtype_kmeans", padding_value = "Others"):
+    
+    adata_neuron = adata_neuron.copy()
+    granule_adata = granule_adata.copy()
+    
+    # neuron and granule coordinates, granule subtypes
+    neuron_coords = adata_neuron.obs[loc_key].to_numpy()
+    granule_coords = granule_adata.obs[loc_key].to_numpy()
+    granule_subtypes = granule_adata.obs[gnl_subtype_key].astype(str).to_numpy()
+    
+    # include padding category
+    unique_subtypes = np.unique(granule_subtypes).tolist()
+    if padding_value not in unique_subtypes:
+        unique_subtypes.append(padding_value)
+    
+    encoder = OneHotEncoder(categories = [unique_subtypes], sparse = False, handle_unknown = "ignore")
+    encoder.fit(np.array(unique_subtypes).reshape(-1, 1))
+    S = len(unique_subtypes)
+    
+    # k-d tree
+    tree = make_tree(d1 = granule_coords[:, 0], d2 = granule_coords[:, 1])
+    distances, indices = tree.query(neuron_coords, k = k, distance_upper_bound = radius)
+    
+    # initialize output
+    n_neurons = neuron_coords.shape[0]
+    embeddings = np.zeros((n_neurons, k, S), dtype = float)
+
+    for i in range(n_neurons):
+        for k in range(k):
+            idx = indices[i, k]
+            dist = distances[i, k]
+            if idx == granule_coords.shape[0] or np.isinf(dist):
+                subtype = padding_value
+            else:
+                subtype = granule_subtypes[idx]
+            onehot = encoder.transform([[subtype]])[0]
+            embeddings[i, k, :] = onehot
+
+    return embeddings, encoder.categories_[0]
+
+
+# [MAIN] numpy array, neuron embeddings based on neighboring granules
+def neuron_embedding_spatial_weight(adata_neuron, granule_adata, radius = 10, sigma = 10, loc_key = ["global_x", "global_y"], gnl_subtype_key = "granule_subtype_kmeans", padding_value = "Others"):
+    
+    adata_neuron = adata_neuron.copy()
+    granule_adata = granule_adata.copy()
+    
+    # neuron and granule coordinates, granule subtypes
+    neuron_coords = adata_neuron.obs[loc_key].to_numpy()
+    granule_coords = granule_adata.obs[loc_key].to_numpy()
+    granule_subtypes = granule_adata.obs[gnl_subtype_key].astype(str).to_numpy()
+    
+    # include padding category
+    unique_subtypes = np.unique(granule_subtypes).tolist()
+    if padding_value not in unique_subtypes:
+        unique_subtypes.append(padding_value)
+    
+    encoder = OneHotEncoder(categories = [unique_subtypes], sparse = False, handle_unknown = "ignore")
+    encoder.fit(np.array(unique_subtypes).reshape(-1, 1))
+    S = len(unique_subtypes)
+    
+    # k-d tree
+    tree = make_tree(d1 = granule_coords[:, 0], d2 = granule_coords[:, 1])
+    all_neighbors = tree.query_ball_point(neuron_coords, r = radius)
+    
+    # initialize output
+    n_neurons = neuron_coords.shape[0]
+    embeddings = np.zeros((n_neurons, S), dtype = float)
+
+    for i, neighbor_indices in enumerate(all_neighbors):
+        if not neighbor_indices:
+            # no neighbors, assign to padding subtype
+            embeddings[i] = encoder.transform([[padding_value]])[0]
+            continue
+
+        # get neighbor subtypes and distances
+        neighbor_coords = granule_coords[neighbor_indices]
+        dists = np.linalg.norm(neuron_coords[i] - neighbor_coords, axis = 1)
+        weights = np.exp(- dists / sigma)
+
+        # encode subtypes to one-hot and weight them
+        subtypes = granule_subtypes[neighbor_indices]
+        onehots = encoder.transform(subtypes.reshape(-1, 1))
+        weighted_sum = (weights[:, np.newaxis] * onehots).sum(axis = 0)
+
+        # normalize to make it a composition vector
+        embeddings[i] = weighted_sum / weights.sum()
+
+    return embeddings, encoder.categories_[0]

mcDETECT/utils.py

@@ -0,0 +1,145 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from matplotlib import colors as mcolors
+from rtree import index
+from scipy.spatial import cKDTree
+from scipy.stats import rankdata
+from shapely.geometry import Point
+
+
+def find_threshold_index(cumsum_list, threshold = 0.99):
+    total = cumsum_list[-1]
+    for i, value in enumerate(cumsum_list):
+        if value >= threshold * total:
+            return i
+    return None
+
+
+def closest(lst, K):
+    return lst[min(range(len(lst)), key = lambda i: abs(lst[i] - K))]
+
+
+def make_tree(d1 = None, d2 = None, d3 = None):
+    active_dimensions = [dimension for dimension in [d1, d2, d3] if dimension is not None]
+    if len(active_dimensions) == 1:
+        points = np.c_[active_dimensions[0].ravel()]
+    elif len(active_dimensions) == 2:
+        points = np.c_[active_dimensions[0].ravel(), active_dimensions[1].ravel()]
+    elif len(active_dimensions) == 3:
+        points = np.c_[active_dimensions[0].ravel(), active_dimensions[1].ravel(), active_dimensions[2].ravel()]
+    return cKDTree(points)
+
+
+def make_rtree(spheres):
+    p = index.Property()
+    idx = index.Index(properties = p)
+    for i, sphere in enumerate(spheres.itertuples()):
+        center = Point(sphere.sphere_x, sphere.sphere_y)
+        bounds = (center.x - sphere.sphere_r,
+                  center.y - sphere.sphere_r,
+                  center.x + sphere.sphere_r,
+                  center.y + sphere.sphere_r)
+        idx.insert(i, bounds)
+    return idx
+
+
+def scale(array, max = 1):
+    new_array = (array - np.min(array)) / (np.max(array) - np.min(array)) * max
+    return new_array
+
+
+def weighted_corr(estimated, actual, weights):
+    
+    estimated = np.array(estimated)
+    actual = np.array(actual)
+    weights = np.array(weights)
+
+    # weighted mean
+    mean_estimated = np.average(estimated, weights = weights)
+    mean_actual = np.average(actual, weights = weights)
+
+    # weighted covariance
+    cov_w = np.sum(weights * (estimated - mean_estimated) * (actual - mean_actual)) / np.sum(weights)
+
+    # weighted variances
+    var_estimated = np.sum(weights * (estimated - mean_estimated) ** 2) / np.sum(weights)
+    var_actual = np.sum(weights * (actual - mean_actual) ** 2) / np.sum(weights)
+
+    # weighted correlation coefficient
+    weighted_corr = cov_w / np.sqrt(var_estimated * var_actual)
+    
+    return weighted_corr
+
+
+def weighted_spearmanr(A, B, weights):
+    
+    A = np.array(A)
+    B = np.array(B)
+    weights = np.array(weights)
+
+    # rank the data
+    R_A = rankdata(A)
+    R_B = rankdata(B)
+
+    # weighted mean
+    mean_R_A_w = np.average(R_A, weights=weights)
+    mean_R_B_w = np.average(R_B, weights=weights)
+
+    # weighted covariance
+    cov_w = np.sum(weights * (R_A - mean_R_A_w) * (R_B - mean_R_B_w)) / np.sum(weights)
+
+    # weighted variances
+    var_R_A_w = np.sum(weights * (R_A - mean_R_A_w)**2) / np.sum(weights)
+    var_R_B_w = np.sum(weights * (R_B - mean_R_B_w)**2) / np.sum(weights)
+
+    # weighted Spearman correlation coefficient
+    weighted_spearman_corr = cov_w / np.sqrt(var_R_A_w * var_R_B_w)
+    
+    return weighted_spearman_corr
+
+
+def assign_palette_to_adata(adata, obs_key = "granule_expr_cluster_hierarchical", cmap_name = "tab10"):
+    
+    adata = adata.copy()
+    
+    # ensure the column is categorical
+    if not pd.api.types.is_categorical_dtype(adata.obs[obs_key]):
+        adata.obs[obs_key] = adata.obs[obs_key].astype("category")
+
+    # extract categories and number of levels
+    categories = adata.obs[obs_key].cat.categories
+    n_categories = len(categories)
+
+    # choose or extend the colormap
+    base_colors = plt.get_cmap(cmap_name).colors
+    if n_categories > len(base_colors):
+        color_palette = sns.color_palette(cmap_name, n_categories)
+    else:
+        color_palette = base_colors[:n_categories]
+
+    # convert to hex and assign
+    adata.uns[f"{obs_key}_colors"] = [mcolors.to_hex(c) for c in color_palette]
+    
+    return adata
+
+
+def p_val_to_star(p):
+    if p > 0.05:
+        return "ns"
+    elif p > 0.01:
+        return "*"
+    elif p > 0.001:
+        return "**"
+    else:
+        return "***"
+
+
+def top_columns_above_threshold(row, threshold=0.5):
+    sorted_row = row.sort_values(ascending=False)
+    cumsum = sorted_row.cumsum()
+    # Find how many top columns are needed to exceed the threshold
+    n = (cumsum > threshold).idxmax()
+    # Slice up to and including the index that crosses the threshold
+    return sorted_row.loc[:n].index.tolist()

mcdetect-2.0.1.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: mcDETECT
+Version: 2.0.1
+Summary: Uncovering the dark transcriptome in polarized neuronal compartments with mcDETECT
+Home-page: https://github.com/chen-yang-yuan/mcDETECT
+Author: Chenyang Yuan
+Author-email: chenyang.yuan@emory.edu
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anndata
+Requires-Dist: miniball
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: rtree
+Requires-Dist: scanpy
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: shapely
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# mcDETECT
+
+## Uncovering the dark transcriptome in polarized neuronal compartments with mcDETECT
+
+#### Chenyang Yuan, Krupa Patel, Hongshun Shi, Hsiao-Lin V. Wang, Feng Wang, Ronghua Li, Yangping Li, Victor G. Corces, Hailing Shi, Sulagna Das, Jindan Yu, Peng Jin, Bing Yao* and Jian Hu*
+
+mcDETECT is a computational framework designed to study the dark transcriptome related to polarized compartments in brain using *in situ* spatial transcriptomics (iST) data. It begins by examining the subcellular distribution of mRNAs in an iST sample. Each mRNA molecule is treated as a distinct point with its own 3D spatial coordinates considering the thickness of the sample. Unlike many cell-type marker genes, which are typically found within the nucleus or soma, compartmentalized mRNAs often form small aggregates outside the soma. mcDETECT uses a density-based clustering approach to identify these extrasomatic aggregates. This involves calculating the Euclidean distance between mRNA points and defining the neighborhood of each point within a specified search radius. Points are then categorized as core points, border points, or noise points based on their reachability from neighboring points. mcDETECT recognizes each connected bundle of core and border points as a mRNA aggregate. To minimize false positives, it excludes aggregates that substantially overlap with somata, which are estimated by dilating the nuclear masks derived from DAPI staining. mcDETECT then repeats this process for multiple granule markers, merging aggregates from different markers that exhibit high spatial overlap. After aggregating across all markers, an additional filtering step removes aggregates containing mRNAs from negative control genes, which are known to be enriched exclusively in nuclei and somata. The remaining aggregates are considered individual RNA granules. mcDETECT then computes the minimum enclosing sphere for each aggregate to connect neighboring mRNA molecules from all measured genes and summarizes their counts, thereby defining the spatial transcriptome profile of individual RNA granules.

mcdetect-2.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+mcDETECT/__init__.py,sha256=o9fQTRgcHPisSCcv0Cy-AtdiTSWrj-ITBK_FQxfnmKE,174
+mcDETECT/model.py,sha256=-r2_Ve0wxOALxiFk0REa58WjMea495yLZ6oXT-WWekw,28046
+mcDETECT/utils.py,sha256=kKw7KnrS-0llqtT32S_PDkag1jk4CWYkSm-FZeIJFAw,4510
+mcdetect-2.0.1.dist-info/licenses/LICENSE,sha256=uxq-shEWOGTIGVnQLmpElILmfCkuUhFZRAMnZUiKvtg,1070
+mcdetect-2.0.1.dist-info/METADATA,sha256=qMO7hrWgabHHp1_UxlDvsLmQYaBC7Nf85RPNxyBvA8o,3016
+mcdetect-2.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcdetect-2.0.1.dist-info/top_level.txt,sha256=WwzBojt5U-T2hZ8llO6XgpM9OFIBkWQQldQKu19O8EY,9
+mcdetect-2.0.1.dist-info/RECORD,,

{mcdetect-1.0.12.dist-info → mcdetect-2.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

mcdetect-1.0.12.dist-info/METADATA

@@ -1,39 +0,0 @@
-Metadata-Version: 2.2
-Name: mcDETECT
-Version: 1.0.12
-Summary: mcDETECT: Decoding 3D Spatial Synaptic Transcriptomes with Subcellular-Resolution Spatial Transcriptomics
-Home-page: https://github.com/chen-yang-yuan/mcDETECT
-Author: Chenyang Yuan
-Author-email: chenyang.yuan@emory.edu
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: anndata
-Requires-Dist: miniball
-Requires-Dist: numpy
-Requires-Dist: pandas
-Requires-Dist: rtree
-Requires-Dist: scanpy
-Requires-Dist: scikit-learn
-Requires-Dist: scipy
-Requires-Dist: shapely
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# mcDETECT
-
-## mcDETECT: Decoding 3D Spatial Synaptic Transcriptomes with Subcellular-Resolution Spatial Transcriptomics
-
-#### Chenyang Yuan, Krupa Patel, Hongshun Shi, Hsiao-Lin V. Wang, Feng Wang, Ronghua Li, Yangping Li, Victor G. Corces, Hailing Shi, Sulagna Das, Jindan Yu, Peng Jin, Bing Yao* and Jian Hu*
-
-mcDETECT is a computational framework designed to identify and profile individual synapses using *in situ* spatial transcriptomics (iST) data. It starts by examining the subcellular distribution of synaptic mRNAs in an iST sample. Unlike cell-type specific marker genes, which are typically found within nuclei, mRNAs of synaptic markers often form small aggregations outside the nuclei. mcDETECT uses a density-based clustering approach to identify these extranuclear aggregations. This involves calculating the Euclidean distance between mRNA points and defining the neighborhood of each point within a specified search radius. Points are then categorized into core points, border points, and noise points based on their reachability from neighboring points. mcDETECT recognizes each bundle of core and border points as a synaptic aggregation. To minimize false positives, it excludes aggregations that significantly overlap with nuclei identified by DAPI staining. Subsequently, mcDETECT repeats this process for multiple synaptic markers, merging aggregations from different markers with high overlaps. After encompassing all markers, an additional filtering step is performed to remove aggregations that contain mRNAs from negative control genes, which are known to be enriched only in nuclei. The remaining aggregations are considered individual synaptic aggregations. mcDETECT then uses the minimum enclosing sphere of each aggregation to gather all mRNA molecules and summarizes their counts for all measured genes to define the spatial transcriptome profile of individual synapses.

mcdetect-1.0.12.dist-info/RECORD

@@ -1,7 +0,0 @@
-mcDETECT/__init__.py,sha256=8DC3jJ35kT7b51bP9HtbDsCRc8_vT6nUaXCZBaSM5Tg,59
-mcDETECT/model.py,sha256=pl6BOByor3Czj1UbxQX7_VzBUyNhz1tG_z7IGz2nR80,21462
-mcdetect-1.0.12.dist-info/LICENSE,sha256=uxq-shEWOGTIGVnQLmpElILmfCkuUhFZRAMnZUiKvtg,1070
-mcdetect-1.0.12.dist-info/METADATA,sha256=AJjMolAwV98Px9PioTv0U_iJl0ypTKMFRgSvCQbBkAg,2820
-mcdetect-1.0.12.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-mcdetect-1.0.12.dist-info/top_level.txt,sha256=WwzBojt5U-T2hZ8llO6XgpM9OFIBkWQQldQKu19O8EY,9
-mcdetect-1.0.12.dist-info/RECORD,,