pyCoReGraph 0.0.1a1__py3-none-any.whl

coregraph/__init__.py

@@ -0,0 +1,57 @@
+__version__ = "0.0.1a1"
+
+# Models
+from coregraph.models import (
+    CoReGraph_Cors,
+    CoReGraph_Graphics,
+    CoReGraph,
+    StarGraph,
+)
+
+# Analysis
+from coregraph.analysis.queries import (
+    get_correlation,
+    get_all_correlations,
+    get_mac,
+    get_mac_results,
+    get_regulated_genes,
+    get_regulator_genes,
+)
+
+# Graphics
+from coregraph.graphics.plots import (
+    plot_expression,
+    plot_correlations,
+)
+
+from coregraph.graphics.animations import (
+    animate_correlations,
+)
+
+from coregraph.graphics.network import (
+    animate_network,
+)
+
+from coregraph.analysis.subset import (
+    starry,
+    subset_coregraph,
+)
+
+__all__ = [
+    "CoReGraph",
+    "CoReGraph_Cors",
+    "CoReGraph_Graphics",
+    "StarGraph",
+    "get_correlation",
+    "get_all_correlations",
+    "get_mac",
+    "get_mac_results",
+    "get_regulated_genes",
+    "get_regulator_genes",
+    "plot_expression",
+    "plot_correlations",
+    "animate_correlations",
+    "animate_network",
+    "starry",
+    "subset_coregraph"
+]

coregraph/analysis/__init__.py

@@ -0,0 +1,45 @@
+from .correlations import (
+    _calculate_all_cors,
+    _calculate_LEAP_cors,
+    _calculate_star_cors,
+)
+
+from .bins import (
+    _calculate_bins,
+)
+
+from .fdr import (
+    _calculate_FDR,
+    _calculate_star_FDR
+)
+
+from .queries import (
+    get_correlation,
+    get_all_correlations,
+    get_mac,
+    get_mac_results,
+    get_regulated_genes,
+    get_regulator_genes,
+)
+
+__all__ = [
+    # Correlations
+    "_calculate_all_cors",
+    "_calculate_LEAP_cors",
+    "_calculate_star_cors",
+
+    # FDR
+    "_calculate_FDR",
+    "_calculate_star_FDR",
+
+    # Bins
+    "_calculate_bins",
+
+    # Queries
+    "get_correlation",
+    "get_all_correlations",
+    "get_mac",
+    "get_mac_results",
+    "get_regulated_genes",
+    "get_regulator_genes",
+]

coregraph/analysis/bins.py

@@ -0,0 +1,23 @@
+## BINS ##
+
+import numpy as np
+
+
+def _calculate_bins(data, pseudotime, n_bins):
+    '''Discretize pseudotime expression in bins'''
+    
+    bin_range = (pseudotime.max() - pseudotime.min())/n_bins
+    bin_seq   = pseudotime.min() + np.arange(1,n_bins)*bin_range
+    bins      = (np.digitize(pseudotime, bin_seq)*bin_range)+(bin_range/2)
+    
+    mean_res  = np.empty((data.shape[0], n_bins), dtype=np.float64)
+    std_res   = np.empty((data.shape[0], n_bins), dtype=np.float64)
+    for i, b in enumerate(np.unique(bins)):
+        mean_res[:,i] = np.mean(data[:,bins==b], axis=1)
+        std_res[:,i]  = np.mean(data[:,bins==b], axis=1)
+
+    mean    = mean_res
+    std     = std_res
+    scaled  = mean/np.max(mean, axis=1)[:, None]
+
+    return bins, mean, std, scaled

coregraph/analysis/correlations.py

@@ -0,0 +1,110 @@
+## CORRELATIONS ##
+
+import numpy as np
+
+
+def _calculate_all_cors(data, window, i, tensor, reflag, MAC, LAG_id, LAG, LAG_means, dim3_start, step=1, num_format=np.array([1,15]), dtype=np.float64):
+    '''Calculate all lagged correlations for a unique given reference i'''
+    dim3 = dim3_start
+    n_genes, n_cells = data.shape
+
+    data_ref     = data[:,i:window+i]
+    mean_ref     = np.mean(data_ref, axis=1)
+    cent_ref     = data_ref.T - mean_ref
+    rowsumx_ref  = np.sum(cent_ref, axis=0).reshape(1, -1)
+    rowsumx2_ref = np.sum(np.square(cent_ref), axis=0).reshape(1, -1)
+
+    for j in range(i, n_cells-window+1, step):
+        data_lag     = data[:,j:window+j]
+        mean_lag     = np.mean(data_lag, axis=1)
+        cent_lag     = data_lag.T - mean_lag
+        rowsumx_lag  = np.sum(cent_lag, axis=0).reshape(1, -1)
+        rowsumx2_lag = np.sum(np.square(cent_lag), axis=0).reshape(1, -1)
+
+        Cor = (np.dot(cent_ref.T, cent_lag) - (1 / window) * np.dot(rowsumx_ref.T, rowsumx_lag)) / \
+            np.dot(np.sqrt(rowsumx2_ref - rowsumx_ref**2 / window).T, np.sqrt(rowsumx2_lag - rowsumx_lag**2 / window))
+        
+        np.fill_diagonal(Cor, 1)
+        Cor              = np.round(np.nan_to_num(Cor, nan=0)*num_format[0], num_format[1])
+        Cor              = Cor.astype(dtype)
+        tensor[:,:,dim3] = Cor
+        LAG_means[dim3]  = mean_lag
+        reflag[dim3,0]   = i
+        reflag[dim3,1]   = j
+
+        # Update MAC
+        ind       = np.abs(MAC) < np.abs(Cor)
+        MAC[ind]         = Cor[ind]
+        LAG[ind]         = j-i
+        LAG_id[0][ind]   = i
+        LAG_id[1][ind]   = j
+        #
+        dim3 += 1
+
+    return dim3, MAC, LAG_id, LAG, LAG_means
+
+def _calculate_LEAP_cors(data, window, i=0, step=1, num_format=np.array([1,15]), dtype=np.float64):
+    '''Calculate all lagged correlations for a unique given reference i using LEAP traditional algorithm'''
+    n_genes, n_cells = data.shape
+    MAC              = np.zeros((n_genes, n_genes))
+    LAG              = np.zeros((n_genes, n_genes))
+
+    data_ref     = data[:,i:window+i]
+    mean_ref     = np.mean(data_ref, axis=1)
+    cent_ref     = data_ref.T - mean_ref
+    rowsumx_ref  = np.sum(cent_ref, axis=0).reshape(1, -1)
+    rowsumx2_ref = np.sum(np.square(cent_ref), axis=0).reshape(1, -1)
+
+    for j in range(i, n_cells - window, step):
+        data_lag     = data[:,j:window+j]
+        mean_lag     = np.mean(data_lag, axis=1)
+        cent_lag     = data_lag.T - mean_lag
+        rowsumx_lag  = np.sum(cent_lag, axis=0).reshape(1, -1)
+        rowsumx2_lag = np.sum(np.square(cent_lag), axis=0).reshape(1, -1)
+
+        Cor = np.dot(cent_ref.T, cent_lag) - (1 / window) * np.dot(rowsumx_ref.T, rowsumx_lag) / \
+            np.dot(np.sqrt(rowsumx2_ref - rowsumx_ref**2 / window).T, np.sqrt(rowsumx2_lag - rowsumx_lag**2 / window))
+        
+        np.fill_diagonal(Cor, 1)
+        Cor              = np.round(np.nan_to_num(Cor, nan=0)*num_format[0], num_format[1])
+        Cor              = Cor.astype(dtype)
+        # Update MAC
+        ind = np.where(np.abs(MAC) > np.abs(Cor))
+        LAG[ind] = j - i
+        MAC[ind] = Cor[ind]
+
+    return MAC, LAG
+
+
+def _calculate_star_cors(data, target_row, MAC, window, i, step=1, num_format=np.array([1,15]), dtype=np.float64):
+    '''Calculate all lagged correlations for a unique given reference i using a single reference row against all rows.'''
+
+    n_genes, n_cells = data.shape
+
+    # Take reference row only
+    data_ref = data[target_row, i:window+i]
+    mean_ref = np.mean(data_ref)
+    cent_ref = data_ref - mean_ref
+
+    sum_ref  = np.sum(cent_ref)
+    sum_ref2 = np.sum(np.square(cent_ref), axis=0)
+
+    for j in range(i, n_cells - window, step):
+        data_lag = data[:, j:window+j]
+        mean_lag = np.mean(data_lag, axis=1)
+        cent_lag = data_lag - mean_lag[:, None]
+
+        rowsumx_lag  = np.sum(cent_lag, axis=1)
+        rowsumx2_lag = np.sum(cent_lag * cent_lag, axis=1)
+        cross = np.dot(cent_lag, cent_ref)
+
+        Cor = (cross - (rowsumx_lag * sum_ref) / window) / \
+            (np.sqrt(rowsumx2_lag - (rowsumx_lag * rowsumx_lag) / window) * np.sqrt(sum_ref2 - (sum_ref * sum_ref) / window))
+        
+        Cor = np.round(np.nan_to_num(Cor, nan=0)*num_format[0], num_format[1])
+        Cor = Cor.astype(dtype)
+
+        ind      = np.where(np.abs(MAC) < np.abs(Cor))
+        MAC[ind] = Cor[ind]
+
+    return MAC

coregraph/analysis/fdr.py

@@ -0,0 +1,100 @@
+## FDR ##
+
+import numpy as np
+
+from coregraph.analysis.correlations import (_calculate_LEAP_cors, _calculate_star_cors)
+
+
+def _calculate_FDR(data, MAC, window, n_perms = 100, FDR_cutoffs = 101, step=1, num_format=np.array([1,15]), dtype=np.float64):
+    '''Calculate False Discovery Rate by permutations'''
+
+    MAC_true  = np.absolute(MAC.copy())
+    samp_size = np.minimum(100, data.shape[0])
+    MACs_perm = np.zeros((n_perms, samp_size, samp_size))
+    np.fill_diagonal(MAC_true, -1)
+
+    # simplified MAC_counter function
+    for n in range(0, n_perms):
+        np.random.seed(n)
+        data_perm = data[0:samp_size,:].copy()
+        inds      = np.random.choice(data.shape[0], size=samp_size, replace=False)
+
+        for z in range(0, samp_size):
+            data_perm[z,:] = np.random.permutation(data[inds[z],:])
+  
+        MAC_p, _ = _calculate_LEAP_cors(data_perm, window, 0, step, num_format, dtype)
+        MAC_p = np.absolute(MAC_p)
+        np.fill_diagonal(MAC_p, -1)
+        MACs_perm[n] = MAC_p
+
+    # Calculate FDR 
+    cors          = np.linspace(0, 1, FDR_cutoffs)
+    num_cors_perm = np.full(FDR_cutoffs, 0)
+    MACs_observed = np.full(FDR_cutoffs, 0)
+
+    for r in range(0, FDR_cutoffs):
+        num_cors_perm[r] += np.sum(MACs_perm >= cors[r])
+        MACs_observed[r] += np.sum(MAC_true >= cors[r])
+
+    perm_size     = samp_size*samp_size-samp_size
+    obs_size      = MAC_true.shape[0]*MAC_true.shape[1]-MAC_true.shape[0]
+    MACs_ave_perm = num_cors_perm/n_perms*(obs_size/perm_size)
+    fdr           = np.full(FDR_cutoffs, np.nan)
+
+    for s in range(0,FDR_cutoffs):
+        if MACs_observed[s] == 0:
+            fdr[s] = 0
+        else:
+            fdr[s] = MACs_ave_perm[s]/MACs_observed[s]
+
+    results = np.column_stack((cors, MACs_observed, MACs_ave_perm, fdr))
+       
+    return results[::-1]
+
+def _calculate_star_FDR(data, target_row, MAC, window, n_perms = 100, FDR_cutoffs = 101, step=1, num_format=np.array([1,15]), dtype=np.float64):
+    '''Calculate False Discovery Rate by permutations for a single reference row against all rows.'''
+
+    MAC_true  = np.absolute(MAC.copy())
+    samp_size = np.minimum(100, data.shape[0])
+    MACs_perm = np.zeros((n_perms, samp_size))
+    MAC_true[target_row] = -1
+
+    # simplified MAC_counter function
+    for n in range(0, n_perms):
+        np.random.seed(n)
+        ref_perm  = data[target_row,:].copy()
+        data_perm = data[0:samp_size-1,:].copy()
+        data_perm = np.concatenate((ref_perm.reshape((1,-1)), data_perm))
+        inds      = np.random.choice(data.shape[0], size=samp_size, replace=False)
+
+        for z in range(0, samp_size):
+            data_perm[z,:] = np.random.permutation(data[inds[z],:])
+  
+        MAC_p        = _calculate_star_cors(data_perm, 0, np.zeros((samp_size), dtype=dtype), window, i=0, step=step, num_format=num_format, dtype=dtype)
+        MAC_p        = np.absolute(MAC_p)
+        MAC_p[0]     = -1
+        MACs_perm[n] = MAC_p
+
+    ### Calculate FDR ###
+    cors          = np.linspace(0, 1, FDR_cutoffs)
+    num_cors_perm = np.full(FDR_cutoffs, 0)
+    MACs_observed = np.full(FDR_cutoffs, 0)
+
+    for r in range(0, FDR_cutoffs):
+        num_cors_perm[r] += np.sum(MACs_perm >= cors[r])
+        MACs_observed[r] += np.sum(MAC_true >= cors[r])
+
+    perm_size     = samp_size-1
+    obs_size      = MAC_true.shape[0]-1
+    MACs_ave_perm = num_cors_perm/n_perms*(obs_size/perm_size)
+    fdr           = np.full(FDR_cutoffs, np.nan)
+
+    for s in range(0,FDR_cutoffs):
+        if MACs_observed[s] == 0:
+            fdr[s] = 0
+        else:
+            fdr[s] = MACs_ave_perm[s]/MACs_observed[s]
+
+    results = np.column_stack((cors, MACs_observed, MACs_ave_perm, fdr))
+       
+    return results[::-1]

coregraph/analysis/queries.py

@@ -0,0 +1,118 @@
+## QUERIES ##
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+from coregraph.utils.decorators import (requires_cors, requires_FDR)
+
+
+@requires_cors
+def get_correlation(C: CoReGraph, regulator: str, target: str, ref_lag: tuple[int, int]) -> float:
+    '''Get correlation value between two genes at a specific (reference, lag) window pair.'''  
+    ref, lag = ref_lag
+
+    if (ref % C.cors.step != 0) or (lag % C.cors.step != 0):
+        raise ValueError(f"ref_lag must be multiples of step={C.cors.step}")
+
+    reg_idx = C.gene_to_idx[regulator]
+    tar_idx = C.gene_to_idx[target]
+
+    if ref <= lag:
+        tensor_i = reg_idx
+        tensor_j = tar_idx
+        search_ref = ref
+        search_lag = lag
+    else:
+        tensor_i = tar_idx
+        tensor_j = reg_idx
+        search_ref = lag
+        search_lag = ref
+
+    dim3 = np.argwhere((C.cors.reflag[:, 0] == search_ref) & (C.cors.reflag[:, 1] == search_lag))[0][0]
+
+    value = (C.cors.tensor[tensor_i, tensor_j, dim3] / C.cors.num_format[0])
+
+    return float(value)
+
+
+@requires_cors
+def get_all_correlations(C: CoReGraph, regulator: str, target: str, ref: int) -> np.ndarray:
+    '''Get all lagged correlations between two genes for a fixed reference window.'''
+    if (ref % C.cors.step != 0) :
+        raise ValueError(f"ref must be a multiple of step={C.cors.step}")
+
+    correlations = np.empty(C.cors.n_steps, dtype=C.cors.dtype)
+
+    for i in range(C.cors.n_steps):
+        lag = i * C.cors.step
+        correlations[i] = get_correlation(C,regulator,target,(ref, lag))
+
+    return correlations
+
+
+@requires_cors
+def get_mac(C: CoReGraph, regulator: str, target: str) -> dict:
+    '''Get maximal absolute correlation (MAC) and corresponding reference/lag pair for two genes.'''
+    reg_idx = C.gene_to_idx[regulator]
+    tar_idx = C.gene_to_idx[target]
+
+    return {
+        "ref": int(C.cors.LAG_id[0, reg_idx, tar_idx]), 
+        "lag": int(C.cors.LAG_id[1, reg_idx, tar_idx]),
+        "cor": float(C.cors.MAC[reg_idx, tar_idx] / C.cors.num_format[0])
+        }
+
+
+@requires_cors
+def get_mac_results(C: CoReGraph) -> tuple[pd.DataFrame, pd.DataFrame]:
+    '''Get MAC and LAG matrices.'''
+    mac_df = pd.DataFrame(C.cors.MAC / C.cors.num_format[0], index=C.gene_id, columns=C.gene_id)
+    lag_df = pd.DataFrame(C.cors.LAG, index=C.gene_id, columns=C.gene_id)
+
+    return mac_df, lag_df
+
+
+@requires_cors
+@requires_FDR
+def get_regulated_genes(C: CoReGraph, regulator: str, cor_threshold: float=0.0) -> pd.DataFrame:
+    '''Get genes regulated by a regulator gene.'''
+    reg_idx = C.gene_to_idx[regulator]
+
+    values = (C.cors.MAC[reg_idx, :] / C.cors.num_format[0])
+
+    df = pd.DataFrame({
+        "gene": C.gene_id,
+        "correlation": values,
+        "lag": C.cors.LAG[reg_idx, :]
+        })
+
+    df = df[np.abs(df["correlation"]) > cor_threshold]
+
+    df = df.sort_values(by="correlation", key=np.abs, ascending=False)
+
+    return df.set_index("gene")
+
+
+@requires_cors
+@requires_FDR
+def get_regulator_genes(C: CoReGraph, target: str, cor_threshold: float=0.0) -> pd.DataFrame:
+    '''Get genes regulated by a regulator gene.'''
+    tar_idx = C.gene_to_idx[target]
+
+    values = (C.cors.MAC[:, tar_idx] / C.cors.num_format[0])
+
+    df = pd.DataFrame({
+        "gene": C.gene_id,
+        "correlation": values,
+        "lag": C.cors.LAG[:, tar_idx]
+        })
+
+    df = df[np.abs(df["correlation"]) > cor_threshold]
+
+    df = df.sort_values(by="correlation", key=np.abs, ascending=False)
+
+    return df.set_index("gene")
+
+

coregraph/analysis/subset.py

@@ -0,0 +1,64 @@
+## REDUCTIONS ##
+
+import numpy as np
+import pandas as pd
+
+from tqdm import tqdm
+
+from coregraph.models.coregraph import CoReGraph
+from coregraph.models.stargraph import StarGraph
+
+from coregraph.analysis.correlations import _calculate_star_cors
+from coregraph.analysis.fdr import _calculate_star_FDR
+from coregraph.utils.validation import _solve_step
+
+
+def starry(x, central_gene, window, FDR_thr=0.05, n_perms=100, FDR_cutoffs=501, step=None, n_steps=None, verbose=False): 
+    '''Wrapped function to estimate starry gene regulatory network centered on a given gene'''
+    n_genes, n_cells = x.data.shape
+    target_row       = x.gene_id.index(central_gene) 
+    step, n_steps    = _solve_step(step, n_steps, window, n_cells)
+
+    ## Calculate MAC ##
+    MAC      = np.zeros((n_genes), dtype=np.float64)
+
+    np.seterr(divide='ignore', invalid='ignore')
+    iterator = tqdm(range(0, n_cells-window+1, step), desc="Calculating Correlations", disable=not verbose)
+    for i in iterator:
+        MAC = _calculate_star_cors(x.data, target_row, MAC, window, i, step)
+
+    ## Calculate FDR ##
+    FDR = _calculate_star_FDR(x.data, target_row, MAC, window, n_perms, FDR_cutoffs, step)
+    FDR = pd.DataFrame(FDR)
+    FDR.columns            = ["cors", "MACs_observed", "MACs_ave_perm", "FDR"]
+    FDR[["MACs_observed"]] = FDR[["MACs_observed"]].astype(int)
+
+    cor_thr   = min(FDR['cors'][FDR['FDR'] < FDR_thr])
+    MAC       = pd.DataFrame(MAC, index=x.gene_id, columns=['MAC'])
+    MAC       = MAC.sort_values(by='MAC', key=abs, ascending=False)
+
+    ## Create a new object and fill in it ##
+    star = StarGraph()
+    star.central_gene = central_gene
+    star.window       = window
+    star.step         = step
+    star.n_steps      = n_steps
+    star.MAC          = MAC
+    star.FDR          = FDR
+    star.set_FDR_threshold(FDR_thr)
+    
+    return star
+
+
+def subset_coregraph(C: CoReGraph, gene_list: list[str]) -> CoReGraph:
+    id_dict = {}
+    for i, b in enumerate(C.gene_id):
+        id_dict[b] = i
+
+    shared_id = [id_dict[g] for g in gene_list]
+    shared_id.sort()
+    subdata   = C.data[shared_id,:]
+    subid     = [C.gene_id[g] for g in shared_id]
+
+    subobject = CoReGraph(subdata, C.pseudotime, subid, C.cell_id)
+    return subobject

coregraph/graphics/__init__.py

@@ -0,0 +1,33 @@
+from .colors import (
+    ColorBlind,
+)
+
+from .plots import (
+    plot_expression,
+    plot_correlations,
+)
+
+from .animations import (
+    animate_correlations,
+)
+
+from .network import (
+    animate_network,
+)
+
+__all__ = [
+    # Colors
+    "ColorBlind",
+
+    # Plots
+    "plot_expression",
+    "plot_correlations",
+
+    # Animations
+    "animate_correlations",
+
+    # Network
+    "animate_network",
+]
+
+

coregraph/graphics/animations.py

@@ -0,0 +1,56 @@
+## ANIMATIONS ##
+
+from __future__ import annotations
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+
+from matplotlib.animation import FuncAnimation
+
+from coregraph.graphics.colors import ColorBlind
+from coregraph.analysis.queries import (get_all_correlations)
+from coregraph.utils.decorators import (requires_cors, requires_bins)
+
+
+@requires_bins
+@requires_cors
+def animate_correlations(C: CoReGraph, regulator: str, target: str, ref: int, scaled: bool=False, decimals: int=15, color: list=(ColorBlind[0], ColorBlind[3]), linewidth: float=1, figsize: tuple=(8,4)):
+    '''Animate lagged correlations.'''
+    if C.graphics.n_bins is None:
+        raise ValueError("Bins have not been calculated.")
+    
+    values        = (C.graphics.scaled if scaled else C.graphics.mean)
+    reg_idx       = C.gene_to_idx[regulator]
+    tar_idx       = C.gene_to_idx[target]
+    y_max         = np.max([values[reg_idx, :], values[tar_idx, :]]) * 1.1
+    all_cors      = get_all_correlations(C, regulator, target, ref)
+    all_cors_norm = (all_cors / np.max(np.abs(all_cors)))
+    
+    fig, ax = plt.subplots(1, 2, figsize=figsize, width_ratios=[25, 1],)
+    x       = np.unique(C.graphics.bin_id)
+
+    # Regulator and target lines
+    ax[0].plot(x, values[reg_idx, :], color=color[0])
+    ax[0].plot(x, values[tar_idx, :], color=color[1],)
+
+    fixed_rect  = ax[0].add_patch(patches.Rectangle((ref, 0), C.cors.window, y_max, facecolor=color[0], alpha=0.1,))
+    moving_rect = ax[0].add_patch(patches.Rectangle((0, 0), C.cors.window, y_max, facecolor=color[1], alpha=0.1,))
+
+    cor_text = ax[0].annotate("", (C.n_cells * 0.01, y_max * 0.8))
+    lag_text = ax[0].annotate("", (C.n_cells * 0.01, y_max * 0.9))
+
+    def update(frame):
+        lag = frame * C.cors.step
+        moving_rect.set_x(lag)
+        cor = all_cors[frame]
+        cor_text.set_text(f"cor = {np.round(cor, decimals)}")
+        lag_text.set_text(f"lag = {lag}")
+
+        return (moving_rect, cor_text, lag_text)
+
+    ani = FuncAnimation(fig, update, frames=C.cors.n_steps, blit=True)
+    #HTML(ani.to_jshtml())
+    return ani
+
+

coregraph/graphics/colors.py

@@ -0,0 +1,9 @@
+## COLORS ##
+
+# Colorblind friendly set of colors
+Blues      = ['#016BA0','#5F9ED1','#A1C8EB','#3399FF', '#006ddb','#330066']
+YReds      = ['#FF0000','#FF9933','#F0E442','#ffff6d','#FF7070']
+Greys      = ['#131313','#555555','#809099','#CFCFCF','#F2F4F4']
+Others     = ['#FFBBAB']
+
+ColorBlind = [Blues[0], YReds[0], Blues[1], YReds[1], Blues[2], YReds[2], Blues[3], YReds[3], Blues[4], YReds[4], Blues[5], Others[0], Greys[0], Greys[1], Greys[2], Greys[3], Greys[4]]