spatools 0.2.0__py3-none-any.whl

Tutorials/manual_cuts.py

@@ -0,0 +1,7 @@
+from spatools.tools.tl import SelectionTool
+
+tool: SelectionTool = SelectionTool("/mnt/SATA/spatialPaper/data/corrected")
+adata = tool.run()
+
+if "selected_area" in adata.obs.columns:
+    print(adata.obs["selected_area"].value_counts())

scripts/convert_point_in_barcodes.py

@@ -0,0 +1,36 @@
+import pandas as pd
+import scanpy as sc
+from spatools.tools.tl import correlate_distances
+
+adata = sc.read("/media/SATA/My_decon_package/redo_/data/output2/concat/scvi_5000_man_cuts.h5ad")
+adata = correlate_distances(adata, is_concatenated=True, cluster_col="clusters_0.6", batch_key="batch")
+
+def spot_mean_by_neighbors(adata):
+    df = adata.uns["spatools"]
+    df_final = pd.DataFrame({})
+    for i, n in enumerate(df["point_name"].unique()):
+        df_subset_point = df[df["point_name"] == i]
+        if df_subset_point["color"].nunique() > 1:
+            print("Existe pelo menos um valor diferente")
+
+        elif df["color"].nunique() == 1:
+            c = df["color"].unique()[0]
+            df["color_neigh"] = [int(i) for i in df["color_neigh"]]
+            df_counts = pd.DataFrame(df["color_neigh"].value_counts(normalize=True))
+            df_counts["color"] = c
+            df_final["color"].iloc[n]
+
+    return 
+
+spot_mean_by_neighbors(adata=adata)
+
+
+
+def point_name_to_barcodes(df_barcodes: pd.DataFrame | list, df_point_name: pd.DataFrame | list):
+    # convertendo se necessario
+    if type(df_barcodes) == list:
+        df_barcodes = pd.DataFrame(df_barcodes)
+    if type(df_point_name) == list:
+        df_point_name = pd.DataFrame(df_point_name)
+
+    pass

scripts/main.py

@@ -0,0 +1,354 @@
+import numpy as np
+import scanpy as sc
+import pandas as pd
+from anndata import AnnData
+from scipy.spatial.distance import cdist
+import matplotlib
+
+matplotlib.use("Qt5Agg")
+print(matplotlib.get_backend())
+########################################################################################
+
+
+# loading bdata
+bdata = sc.read("/mnt/SATA/Cell2_loucura/data/input/bdata_normal_free.h5ad")
+bdata.obs.rename(columns={"batch": "sample"}, inplace=True)
+
+# correcting names
+bdata.obsm["q05_cell_abundance_w_sf"].columns = bdata.uns["mod"]["factor_names"]
+
+# normalizing rows
+df = bdata.obsm["q05_cell_abundance_w_sf"]
+df = df.div(df.sum(axis=1), axis=0)
+bdata.obsm["q05_cell_abundance_w_sf"] = df.copy()
+
+
+########################################################################################
+
+# apenas um check que eh totalmente necessario
+def spatools_check(
+        adata: AnnData, 
+        deconv: bool = False
+    ):
+
+    # changing uns key 
+    if not deconv:
+        uns_value = "spatools"
+    else:
+        uns_value = "deconv_spatools"
+
+    # checking if uns value already exists
+    if not uns_value in adata.uns:
+        return
+    
+    print("Overwriting old analysis!")
+    input = input("Do you want to proceed? [y or n] ").strip().lower()
+    if input == "n":
+        raise Exception("Operation canceled by the user.")
+    elif input == "y":
+        return
+    else:
+        raise Exception("Invalid response. Use 'y' for yes or 'n' for no.")
+
+# pega os vizinhos com base em um limite
+def measure_neighbors_filtered(
+    adata: AnnData,
+    freq_threshold: float = 0.2,
+    distance_factor: float = 1.1,
+    df_freq: pd.DataFrame = None
+):
+    
+    # Creating a DataFrame with barcodes and spatial coordenates
+    df = pd.DataFrame(
+        adata.obsm["spatial"],
+        index=adata.obs_names,
+        columns=["x", "y"]
+    )
+    
+    # Making sure df_freq and df are maching
+    if df_freq:
+        common = df.index.intersection(df_freq.index)
+        df = df.loc[common]
+        df_freq = df_freq.loc[common]
+    else:
+        try:
+            df_freq = adata.obsm["q05_cell_abundance_w_sf"]
+            df_freq.columns = adata.uns["mod"]["factor_names"]
+        except KeyError:
+            raise "'q05_cell_abundance_w_sf' does not exist inside obsm, try to give a 'df_freq' next time"
+        common = df.index.intersection(df_freq.index)
+        df = df.loc[common]
+        df_freq = df_freq.loc[common]
+
+    # dict to store the amount out spots per celltype analysed
+    result = dict()
+
+    # Creating dfs for all the neighbors and initiating loop
+    all_neighbors_dfs = []
+    for cell_type in df_freq.columns:
+    
+        # Filter spots with low frequence > threshold
+        selected = df_freq[cell_type] > freq_threshold
+        selected_spatial = df[selected]
+        
+        # Skip if no spots found for this cell type
+        if len(selected_spatial) == 0:
+            # print(f"⚠️  Skipping {cell_type}: no spots with abundance > {freq_threshold}")
+            continue
+        
+        # Creating an object with all corrds
+        all_points = df[["x", "y"]].values
+        
+        # Creating an oblect with only the selected points
+        selected_points = selected_spatial[["x", "y"]].values
+        
+        # Calculate a matrix of distance between selected and all points
+        dist_matrix = cdist(selected_points, all_points)
+        
+        # Find lower global distance and calculating the threshold distance
+        # Filter out zero distances and check if there are any non-zero distances
+        non_zero_distances = dist_matrix[dist_matrix > 0]
+        if len(non_zero_distances) == 0:
+            # print(f"⚠️  Skipping {cell_type}: no non-zero distances found")
+            continue
+        
+        min_distance = np.min(non_zero_distances)
+        threshold_distance = min_distance * distance_factor
+        
+        # Creating a list of neighbors
+        neighbors_list = []
+        
+        for i, barcode in enumerate(selected_spatial.index):
+            
+            distances = dist_matrix[i]
+            
+            neighbors_idx = np.where(
+                (distances < threshold_distance) &
+                (distances > 0)
+            )[0]
+            
+            x_i, y_i = selected_spatial.loc[barcode, ["x", "y"]]
+            
+            for j in neighbors_idx:
+                
+                neigh_barcode = df.index[j]
+                x_j, y_j = df.iloc[j][["x", "y"]]
+                
+                neighbors_list.append([
+                    barcode,
+                    x_i,
+                    y_i,
+                    neigh_barcode,
+                    x_j,
+                    y_j,
+                    distances[j]
+                ])
+        
+        neighbors_df = pd.DataFrame(
+            neighbors_list,
+            columns=[
+                "barcode",
+                "x",
+                "y",
+                "neighbor_barcode",
+                "x_neighbor",
+                "y_neighbor",
+                "distance"
+            ]
+        )
+
+        # Creating result dict
+        n_spots = len(neighbors_df.barcode.unique())
+        # print(f"✓ {n_spots} spots found with more than {freq_threshold} for {cell_type}")
+        result.update([(cell_type, n_spots)])
+
+        # appending to a big dict
+        neighbors_df["cell_type"] = cell_type
+        all_neighbors_dfs.append(neighbors_df)
+    
+    adata.uns["deconv_result"] = result.copy()
+
+    return pd.concat(all_neighbors_dfs, ignore_index=True)
+
+# Calcula abundancia media de tipos celulares dos vizinhos por amostra
+def get_neighbors_celltype_composition_by_sample(adata: AnnData,
+                                                 sample_id: str = 'sample'):
+    """
+    Calcula a composição média dos vizinhos de cada tipo celular,
+    armazenando um dicionário por amostra em adata.uns["neighbors_composition"].
+    
+    Saída: 
+        adata.uns["neighbors_composition"] = dict[sample] -> DataFrame (linhas=cell_types, colunas=abundância média)
+    """
+    
+    abundance_matrix = adata.obsm['q05_cell_abundance_w_sf']
+    spatools_deconv_df = adata.uns["deconv_spatools"]
+
+    # identificar amostras e tipos celulares
+    samples = spatools_deconv_df['sample'].unique() if 'sample' in spatools_deconv_df.columns else [None]
+    cell_types = spatools_deconv_df['cell_type'].unique()
+    
+    # dicionário final
+    composition_by_sample = {}
+
+    for sample in samples:
+        # DataFrame temporário: linhas = tipos celulares, colunas = abundâncias médias dos vizinhos
+        temp_df = pd.DataFrame(index=cell_types, columns=abundance_matrix.columns, dtype=float)
+
+        for cell_type in cell_types:
+            # subset dos vizinhos do tipo celular na amostra
+            if sample is None:
+                subset_df = spatools_deconv_df[spatools_deconv_df['cell_type'] == cell_type]
+            else:
+                # Filtro da amostra e tipo celular relevante
+                subset_df = spatools_deconv_df[
+                    (spatools_deconv_df['cell_type'] == cell_type) & 
+                    (spatools_deconv_df[sample_id] == sample)
+                ]
+
+            # converte barcodes para indices numericos
+            neighbors_of_type = subset_df['neighbor_barcode'].unique()
+            neighbor_indices = [adata.obs_names.get_loc(barcode) 
+                                for barcode in neighbors_of_type if barcode in adata.obs_names]
+
+            # Se existirem vizinhos, faz o calculo da media das abundancias
+            if len(neighbor_indices) > 0:
+                neighbors_abundance = abundance_matrix.iloc[neighbor_indices]
+                mean_composition = neighbors_abundance.mean(axis=0)
+            else:
+                mean_composition = pd.Series(0.0, index=abundance_matrix.columns)
+
+            # salvar no DataFrame temporário
+            temp_df.loc[cell_type] = mean_composition
+
+        # salvar o DataFrame da amostra no dicionário
+        composition_by_sample[sample if sample is not None else 'ALL'] = temp_df
+
+    # armazenar no AnnData
+    adata.uns["neighbors_composition"] = composition_by_sample
+
+    return adata
+
+# rodar measure_neighbors_filtered mas levando em consideracao que podem existir varias amostras
+def deconv_correlate_distances(adata: AnnData, 
+                        multi_sample: bool = True, 
+                        sample_key: str = "sample",
+                        freq_threshold : int = 0.05):
+    
+    # verifying if the analysis has already being done
+    spatools_check(adata, deconv=True)
+
+    if multi_sample:
+        merged_df = []
+        for i in adata.obs[sample_key].unique():
+            subset = adata[adata.obs[sample_key] == i].copy()
+            all_neighbors_dfs = measure_neighbors_filtered(adata=subset, freq_threshold=freq_threshold)
+            all_neighbors_dfs[sample_key] = i  # add batch column
+            merged_df.append(all_neighbors_dfs)
+
+        # Concatenating individual DataFrames before storing
+        adata.uns["deconv_spatools"] = pd.concat(merged_df, ignore_index=True)
+        adata = get_neighbors_celltype_composition_by_sample(adata=adata)
+
+    else:
+        all_neighbors_dfs = measure_neighbors_filtered(adata=adata, freq_threshold=freq_threshold)
+        adata.uns["deconv_spatools"] = all_neighbors_dfs
+
+    return adata
+
+bdata = deconv_correlate_distances(adata = bdata)
+print(bdata.uns["neighbors_composition"])
+
+##### plot
+import matplotlib.pyplot as plt
+from matplotlib.colors import LinearSegmentedColormap, Normalize
+import seaborn as sns
+import numpy as np
+
+mask = bdata.uns["neighbors_composition"].index.get_level_values(1).str.split("_").str[1] == "GOR"
+df_filtered = neighbors_composition_df[mask]# type: ignore
+df_filtered
+
+# plot dos resultados filtrados por resposta ao tratamento
+def plot_neighbors_composition(composition_matrix: pd.DataFrame,
+                               show=True, 
+                               title: str = "Neighbor Cell Type Composition",
+                               mask_upper=True,
+                               return_object=False):
+    """
+    Plot the neighbors composition matrix as a heatmap.
+    
+    Parameters:
+    -----------
+    composition_matrix : pd.DataFrame
+        DataFrame com tipos celulares como index e colunas
+    show : bool
+        Se deve mostrar o plot
+    title : str
+        Título do plot
+    mask_upper : bool
+        Se deve mascarar o triângulo superior (remove duplicatas simétricas)
+    return_object : bool
+        Se deve retornar o objeto do plot
+    """
+    
+    corr_matrix = composition_matrix.copy()
+    
+    # --- Create mask if needed ---
+    mask = None
+    if mask_upper:
+        mask = np.triu(np.ones_like(corr_matrix, dtype=bool), k=1)
+    
+    # --- Create custom colormap ---
+    vmax = corr_matrix.values.max()
+    vmin = corr_matrix.values.min()
+    
+    # Handle case where all values are the same
+    if vmin == vmax:
+        vmin = vmax - 1
+    
+    norm_range = vmax - vmin
+    zero_pos = max(0.01, min(0.99, (0 - vmin) / norm_range if norm_range != 0 else 0.5))
+    
+    colors = [(0.0, '#0000FF'), (zero_pos, '#FFFFFF'), (1.0, '#FF0000')]
+    cmap = LinearSegmentedColormap.from_list('custom_bwr', colors)
+
+    # --- Plot with seaborn ---
+    plt.figure(figsize=(18, 12))
+    ax = sns.heatmap(corr_matrix, 
+                mask=mask,
+                cmap=cmap, 
+                annot=True, 
+                fmt='.2f',
+                cbar_kws={'label': 'Mean Abundance'},
+                vmin=vmin, 
+                vmax=vmax,
+                linewidths=0.5,
+                linecolor='lightgray')
+
+    # --- Axis and title ---
+    ax.tick_params(axis="x", labelsize=11)
+    ax.tick_params(axis="y", labelsize=11)
+
+    plt.title(title, fontsize=20, pad=20)
+    ax.set_xlabel('Cell Types in Neighbors', fontsize=16)
+    ax.set_ylabel('Query Cell Types', fontsize=16)
+
+    for label in ax.get_xticklabels():
+        x, y = label.get_position()
+        label.set_x(x + 0.5)  # adiciona metade do valor do tick
+
+    plt.xticks(rotation=90, ha='right')
+    plt.yticks(rotation=0)
+
+    if show:
+        plt.tight_layout()
+        plt.show()
+
+    if return_object:
+        return corr_matrix
+
+# Plotar composição de vizinhos (mantém apenas triângulo inferior)
+plot_neighbors_composition(composition_matrix=df_filtered, 
+                          title="Mean Cell Type Composition of Neighbors",
+                          mask_upper=True)

scripts/process_img.py

@@ -0,0 +1,169 @@
+import os
+import cv2 as cv
+import numpy as np
+import pandas as pd
+from anndata import AnnData
+from PIL import Image
+from skimage import io
+from spatools import constants as con
+from typing import List, Any, Optional
+from pybiomart import Server
+import matplotlib.pyplot as plt
+from scipy.spatial import distance
+from multiprocessing import Pool, cpu_count
+
+def process_image(input_image_path,
+                  output_dir: str, 
+                  minDist=50, 
+                  param1=50, 
+                  param2=0.2, 
+                  minRadius=50, 
+                  maxRadius=100):
+    """
+    Process an input image to detect circles using Hough Transform.
+
+    Parameters
+    ----------
+    input_image_path : str
+        The path to the input image file.
+    output_dir : str
+        The directory to save the output files.
+    minDist : int, default=50
+        Minimum distance between detected circles.
+    param1 : int, default=50
+        First method-specific parameter for the Hough Transform (higher threshold).
+    param2 : float, default=0.2
+        Second method-specific parameter for the Hough Transform (accumulator threshold).
+    minRadius : int, default=50
+        Minimum circle radius to be detected.
+    maxRadius : int, default=100
+        Maximum circle radius to be detected.
+
+    Returns
+    -------
+    output_image: png
+        Image containing the detected circles outlined by lines generated with Matplotlib.
+    output_excel : XLSX
+        Path to the Excel file in XLSX format containing a dataframe with the following columns:
+        - Center_X: X-coordinate of the center point.
+        - Center_Y: Y-coordinate of the center point.
+        - Center_Color: Color value of the center point.
+        - Neighbor_X: X-coordinate of the neighboring point.
+        - Neighbor_Y: Y-coordinate of the neighboring point.
+        - Distance: Distance between the center point and the neighboring point.
+        - Point_Name: Name of the point in the format "Point_X_Y".
+        - Color_Code: Mapped color code from the dictionary.
+        - Proximity: Categorization of the distance as 'close' or 'far'.
+        - Neighbor_Cluster: Cluster of the neighboring point.
+        - Combination: Tuple of sorted color codes of center and neighbor points.
+    """
+    # Aumentar o limite de pixels
+    Image.MAX_IMAGE_PIXELS = None
+
+    # Carregar a imagem
+    image = io.imread(input_image_path)
+
+    # Converter RGBA para RGB (ignorando o canal alfa)
+    if image.shape[2] == 4:
+        image_rgb = image[:, :, :3]
+    else:
+        image_rgb = image
+
+    # Converter a imagem RGB para escala de cinza
+    gray_image = cv.cvtColor(image_rgb, cv.COLOR_BGR2GRAY)
+
+    # Detectar círculos usando a Transformada de Hough
+    circles = cv.HoughCircles(
+        gray_image,
+        cv.HOUGH_GRADIENT_ALT,
+        dp=1,
+        minDist=minDist,
+        param1=param1,
+        param2=param2,
+        minRadius=minRadius,
+        maxRadius=maxRadius 
+    )
+
+    if circles is not None:
+        circles = np.uint16(np.around(circles[0, :])).astype("int")
+
+        # Obter a cor do centro de cada círculo e seus raios
+        centers_colors = [(x, y, image_rgb[y, x]) for x, y, _ in circles]
+        radii = circles[:, 2]
+
+        # Calcular a média dos raios e definir a distância limite baseada no círculo e seus 6 vizinhos mais próximos
+        mean_radii_with_neighbors = []
+        for i, (x, y, r) in enumerate(circles):
+            # Calcular a distância para todos os outros círculos
+            distances = np.array([distance.euclidean((x, y), (x2, y2)) for (x2, y2, _) in circles if (x2, y2) != (x, y)])
+            # Obter os índices dos 6 círculos mais próximos
+            nearest_indices = np.argsort(distances)[:6]
+            # Calcular a média dos raios desses 6 círculos mais o círculo atual
+            mean_radius = np.mean(np.append(radii[nearest_indices], r))
+            mean_radii_with_neighbors.append(mean_radius)
+
+        # Definir a distância limite baseada na média dos raios com os vizinhos
+        threshold_distance = 2 * np.mean(mean_radii_with_neighbors) * np.sqrt(3) * 0.9
+
+        # Preparar argumentos para paralelização
+        args = [(centers_colors, i, threshold_distance) for i in range(len(centers_colors))]
+
+        # Usar Pool para paralelizar o cálculo das distâncias
+        with Pool(cpu_count()) as pool:
+            results = pool.map(calculate_distances, args)
+
+        # Combinar os resultados
+        data = [item for sublist in results for item in sublist]
+
+        df = pd.DataFrame(data, columns=['Center_X', 'Center_Y', 'Center_Color', 'Neighbor_X', 'Neighbor_Y', 'Distance'])
+
+        # Adicionar a coluna 'Point_Name'
+        df['Point_Name'] = df.apply(lambda row: f"Point_{row['Center_X']}_{row['Center_Y']}", axis=1)
+
+        # Função para mapear a cor do centro para o dicionário
+        def map_color_to_dict(color):
+            for key, value in con.COLORS_23.items():
+                if tuple(color) == value:
+                    return key
+            return None
+
+        # Adicionar a coluna 'Color_Code'
+        df['Color_Code'] = df['Center_Color'].apply(map_color_to_dict)
+
+        # Adicionar a coluna 'proximity'
+        df['proximity'] = df['Distance'].apply(lambda d: 'close' if d < threshold_distance else 'far')
+
+        # Criar um dicionário para mapear as coordenadas dos vizinhos para seus clusters
+        neighbor_clusters = {f"{x}_{y}": map_color_to_dict(color) for x, y, color in centers_colors}
+
+        # Adicionar a coluna 'Neighbor_Cluster'
+        df['Neighbor_Cluster'] = df.apply(lambda row: neighbor_clusters.get(f"{row['Neighbor_X']}_{row['Neighbor_Y']}"), axis=1)#type:ignore
+
+        # Adicionar a coluna 'combination'
+        df['combination'] = df.apply(lambda row: tuple(sorted((row['Color_Code'], row['Neighbor_Cluster']))), axis=1)
+
+        # Salvar o dataframe em Excel
+        output_excel_path = os.path.join(output_dir, "output_data.xlsx")
+        df.to_excel(output_excel_path, index=False)
+
+        # Plotar a imagem e os círculos detectados
+        fig, ax = plt.subplots(figsize=(10, 10))
+        ax.imshow(image_rgb)
+
+        # Desenhar os círculos
+        for (x, y, r) in circles:
+            circle = plt.Circle((x, y), r, color='black', fill=False, linewidth=0.2)#type:ignore
+            ax.add_patch(circle)
+
+        ax.set_title('Círculos Detectados')
+        plt.axis('off')
+
+        # Salvar a imagem
+        output_image_path = os.path.join(output_dir, "detected_circles.png")
+        plt.savefig(output_image_path, format="png", dpi=1000)
+        plt.close()
+
+        return output_image_path, output_excel_path
+    else:
+        print("Nenhum círculo foi detectado.")
+        return None, None

spatools/__init__.py

@@ -0,0 +1,8 @@
+# Importa os submódulos do pacote
+from . import plotting as pl
+from . import processing as pp
+from . import tools as tl
+from .reading import read
+from . import constants as con
+# Define os módulos exportados ao importar o pacote
+__all__ = ["pl", "pp", "tl", "read", "con"]

spatools/constants.py

@@ -0,0 +1,87 @@
+import os
+
+# dictionary of colors
+COLORS_23 = {
+    0: (0, 32, 111),
+    1: (230, 214, 71),
+    2: (170, 96, 40),
+    3: (19, 177, 81),
+    4: (89, 0, 88),
+    5: (197, 223, 119),
+    6: (1, 135, 226),
+    7: (255, 161, 97),
+    8: (136, 101, 195),
+    9: (252, 80, 111),
+    10: (118, 232, 195),
+    11: (126, 0, 46),
+    12: (42, 82, 0),
+    13: (255, 127, 202),
+    14: (129, 62, 115),
+    15: (255, 135, 143),
+    16: (34, 222, 230),
+    17: (201, 78, 60),
+    18: (131, 110, 32),
+    19: (159, 150, 56),
+    20: (177, 73, 161),
+    21: (128, 77, 17),
+    22: (129, 47, 25)
+}
+
+# dictionary of colors in hex
+COLORS_23_HEX = [
+    "#00206F",  # 0
+    "#E6D647",  # 1
+    "#AA6028",  # 2
+    "#13B151",  # 3
+    "#590058",  # 4
+    "#C5DF77",  # 5
+    "#0187E2",  # 6
+    "#FFA161",  # 7
+    "#8865C3",  # 8
+    "#FC506F",  # 9
+    "#76E8C3",  # 10
+    "#7E002E",  # 11
+    "#2A5200",  # 12
+    "#FF7FCA",  # 13
+    "#813E73",  # 14
+    "#FF878F",  # 15
+    "#22DEE6",  # 16
+    "#C94E3C",  # 17
+    "#836E20",  # 18
+    "#9F9638",  # 19
+    "#B149A1",  # 20
+    "#804D11",  # 21
+    "#812F19"   # 22
+]
+
+
+BATCH_COLORS = ["#d9b85c",
+                "#46ca79",
+                "#bd4eaa",
+                "#7db94c",
+                "#572f83",
+                "#b6b638",
+                "#606ed6",
+                "#808026",
+                "#de6259",
+                "#3c6f24",
+                "#cc4282",
+                "#4da260",
+                "#852a67",
+                "#ae75d7",
+                "#5558a1",
+                "#cc8c33",
+                "#669ce4",
+                "#34d6e0",
+                "#43c8ac",
+                "#aebc65",
+                "#cd4b37",
+                "#8c2343",
+                "#8c5d1b",
+                "#df88cc",
+                "#cc8b52",
+                "#d75f77",
+                "#873319",
+                "#dd7b67",
+                "#ca3d4e"
+                ]

spatools/plotting/__init__.py

@@ -0,0 +1,24 @@
+from .pl import (
+    plot_bar_by_batch,
+    plot_bar_by_group,
+    plot_bar,
+    plot_single_spatial_image,
+    plot_spatial_clusters,
+    plot_clusters_quality_violin_boxplot,
+    outlier_quality,
+    z_score_matrixplot,
+    boxplot_cluster_correlations
+)
+
+# Defina as funções que devem ser acessíveis a partir de 'plotting'
+__all__ = [
+    'plot_bar_by_batch',
+    'plot_bar_by_group',
+    'plot_bar',
+    'plot_single_spatial_image',
+    'plot_spatial_clusters',
+    'plot_clusters_quality_violin_boxplot',
+    'outlier_quality',
+    'z_score_matrixplot',
+    'boxplot_cluster_correlations'
+]