Esempio n. 1
0
def test_plot_conn_mat_nonet_mask(plotting_data):
    """
    Test plot_conn_mat_nonet_mask functionality
    """

    temp_dir = tempfile.TemporaryDirectory()
    dir_path = str(temp_dir.name)
    network = None
    ID = '002'
    thr = 0.95
    node_size = 2
    smooth = 2
    hpass = 0.1
    conn_model = 'sps'
    extract_strategy = 'mean'
    atlas = 'whole_brain_cluster_labels_PCA200'
    roi = None

    conn_matrix = plotting_data['conn_matrix']
    labels = plotting_data['labels']

    start_time = time.time()
    plot_graphs.plot_conn_mat_func(conn_matrix, conn_model, atlas, dir_path,
    ID, network, labels, roi, thr, node_size, smooth, hpass, extract_strategy)
    print("%s%s%s" % ('plot_conn_mat_func (Masking version) --> finished: ',
    str(np.round(time.time() - start_time, 1)), 's'))

    temp_dir.cleanup()
Esempio n. 2
0
def test_plot_conn_mat_nonet_mask():
    """
    Test plot_conn_mat_nonet_mask functionality
    """
    # Set example inputs
    base_dir = str(Path(__file__).parent / "examples")
    dir_path = base_dir + '/002/fmri'
    network = None
    ID = '002'
    thr = 0.95
    node_size = 2
    smooth = 2
    c_boot = 3
    hpass = 0.1
    conn_model = 'sps'
    atlas = 'whole_brain_cluster_labels_PCA200'
    roi = None
    conn_matrix = np.genfromtxt(
        dir_path +
        '/whole_brain_cluster_labels_PCA200/002_Default_est_sps_0.94.txt')
    labels_file_path = dir_path + '/whole_brain_cluster_labels_PCA200/Default_func_labelnames_wb.pkl'
    labels_file = open(labels_file_path, 'rb')
    labels = pickle.load(labels_file)

    start_time = time.time()
    plot_graphs.plot_conn_mat_func(conn_matrix, conn_model, atlas, dir_path,
                                   ID, network, labels, roi, thr, node_size,
                                   smooth, c_boot, hpass)
    print("%s%s%s" % ('plot_conn_mat_func (Masking version) --> finished: ',
                      str(np.round(time.time() - start_time, 1)), 's'))
Esempio n. 3
0
def test_plot_conn_mat_nonet_mask():
    """
    Test plot_conn_mat_nonet_mask functionality
    """
    import tempfile

    base_dir = str(Path(__file__).parent / "examples")
    dir_path = str(tempfile.TemporaryDirectory().name)
    os.makedirs(dir_path)
    network = None
    ID = '002'
    thr = 0.95
    node_size = 2
    smooth = 2
    hpass = 0.1
    conn_model = 'sps'
    extract_strategy = 'mean'
    atlas = 'whole_brain_cluster_labels_PCA200'
    roi = None
    conn_matrix = np.genfromtxt(
        f"{base_dir}/miscellaneous/002_rsn-Default_nodetype-parc_est-sps_thrtype-PROP_thr-0.94.txt"
    )
    labels_file_path = f"{base_dir}/miscellaneous/Default_func_labelnames_wb.pkl"
    labels_file = open(labels_file_path, 'rb')
    labels = pickle.load(labels_file)

    start_time = time.time()
    plot_graphs.plot_conn_mat_func(conn_matrix, conn_model, atlas, dir_path,
                                   ID, network, labels, roi, thr, node_size,
                                   smooth, hpass, extract_strategy)
    print("%s%s%s" % ('plot_conn_mat_func (Masking version) --> finished: ',
                      str(np.round(time.time() - start_time, 1)), 's'))
Esempio n. 4
0
def plot_all_func(conn_matrix, conn_model, atlas, dir_path, ID, network, labels, roi, coords, thr,
                  node_size, edge_threshold, smooth, prune, uatlas, c_boot, norm, binary, hpass):
    """
    Plot adjacency matrix, connectogram, and glass brain for functional connectome.

    Parameters
    ----------
    conn_matrix : array
        NxN matrix.
    conn_model : str
       Connectivity estimation model (e.g. corr for correlation, cov for covariance, sps for precision covariance,
       partcorr for partial correlation). sps type is used by default.
    atlas : str
        Name of atlas parcellation used.
    dir_path : str
        Path to directory containing subject derivative data for given run.
    ID : str
        A subject id or other unique identifier.
    network : str
        Resting-state network based on Yeo-7 and Yeo-17 naming (e.g. 'Default') used to filter nodes in the study of
        brain subgraphs.
    labels : list
        List of string labels corresponding to ROI nodes.
    roi : str
        File path to binarized/boolean region-of-interest Nifti1Image file.
    coords : list
        List of (x, y, z) tuples corresponding to an a-priori defined set (e.g. a coordinate atlas).
    thr : float
        A value, between 0 and 1, to threshold the graph using any variety of methods
        triggered through other options.
    node_size : int
        Spherical centroid node size in the case that coordinate-based centroids
        are used as ROI's.
    edge_threshold : float
        The actual value, between 0 and 1, that the graph was thresholded (can differ from thr if target was not
        successfully obtained.
    smooth : int
        Smoothing width (mm fwhm) to apply to time-series when extracting signal from ROI's.
    prune : bool
        Indicates whether to prune final graph of disconnected nodes/isolates.
    uatlas : str
        File path to atlas parcellation Nifti1Image in MNI template space.
    c_boot : int
        Number of bootstraps if user specified circular-block bootstrapped resampling of the node-extracted time-series.
    norm : int
        Indicates method of normalizing resulting graph.
    binary : bool
        Indicates whether to binarize resulting graph edges to form an
        unweighted graph.
    hpass : bool
        High-pass filter values (Hz) to apply to node-extracted time-series.
    """
    import os
    import os.path as op
    import matplotlib
    matplotlib.use('agg')
    from matplotlib import pyplot as plt
    from nilearn import plotting as niplot
    import pkg_resources
    import networkx as nx
    from pynets.core import thresholding
    from pynets.plotting import plot_gen, plot_graphs
    from pynets.stats.netstats import most_important, prune_disconnected
    try:
        import cPickle as pickle
    except ImportError:
        import _pickle as pickle

    ch2better_loc = pkg_resources.resource_filename("pynets", "templates/ch2better.nii.gz")

    coords = list(coords)
    labels = list(labels)
    if len(coords) > 0:
        dpi_resolution = 500
        if '\'b' in atlas:
            atlas = atlas.decode('utf-8')
        if (prune == 1 or prune == 2) and len(coords) == conn_matrix.shape[0]:
            G_pre = nx.from_numpy_matrix(np.abs(conn_matrix))
            if prune == 1:
                [G, pruned_nodes] = prune_disconnected(G_pre)
            elif prune == 2:
                [G, pruned_nodes] = most_important(G_pre)
            else:
                G = G_pre
                pruned_nodes = []
            pruned_nodes.sort(reverse=True)
            print('(Display)')
            coords_pre = list(coords)
            labels_pre = list(labels)
            if len(pruned_nodes) > 0:
                for j in pruned_nodes:
                    labels_pre.pop(j)
                    coords_pre.pop(j)
                conn_matrix = nx.to_numpy_array(G)
                labels = labels_pre
                coords = coords_pre
            else:
                print('No nodes to prune for plot...')

        coords = list(tuple(x) for x in coords)

        namer_dir = dir_path + '/figures'
        if not os.path.isdir(namer_dir):
            os.makedirs(namer_dir, exist_ok=True)

        # Plot connectogram
        if len(conn_matrix) > 20:
            try:
                plot_gen.plot_connectogram(conn_matrix, conn_model, atlas, namer_dir, ID, network, labels)
            except RuntimeWarning:
                print('\n\n\nWarning: Connectogram plotting failed!')
        else:
            print('Warning: Cannot plot connectogram for graphs smaller than 20 x 20!')

        # Plot adj. matrix based on determined inputs
        if not node_size or node_size == 'None':
            node_size = 'parc'
        plot_graphs.plot_conn_mat_func(conn_matrix, conn_model, atlas, namer_dir, ID, network, labels, roi, thr,
                                       node_size, smooth, c_boot, hpass)

        # Plot connectome
        out_path_fig = "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s" % (namer_dir, '/', ID, '_modality-func_',
                                                             '%s' % ("%s%s%s" % ('rsn-', network, '_') if
                                                                     network is not None else ''),
                                                             '%s' % ("%s%s%s" % ('roi-', op.basename(roi).split('.')[0],
                                                                                 '_') if roi is not None else ''),
                                                             'est-', conn_model, '_',
                                                             '%s' % (
                                                                 "%s%s%s" % ('nodetype-spheres-', node_size, 'mm_') if
                                                                 ((node_size != 'parc') and (node_size is not None))
                                                                 else 'nodetype-parc_'),
                                                             "%s" % ("%s%s%s" % ('boot-', int(c_boot), 'iter_') if
                                                                     float(c_boot) > 0 else ''),
                                                             "%s" % ("%s%s%s" % ('smooth-', smooth, 'fwhm_') if
                                                                     float(smooth) > 0 else ''),
                                                             "%s" % ("%s%s%s" % ('hpass-', hpass, 'Hz_') if
                                                                     hpass is not None else ''),
                                                             '_thr-', thr, '_glass_viz.png')
        if roi:
            # Save coords to pickle
            coord_path = "%s%s%s%s" % (namer_dir, '/coords_', op.basename(roi).split('.')[0], '_plotting.pkl')
            with open(coord_path, 'wb') as f:
                pickle.dump(coords, f, protocol=2)

            # Save labels to pickle
            labels_path = "%s%s%s%s" % (namer_dir, '/labelnames_', op.basename(roi).split('.')[0], '_plotting.pkl')
            with open(labels_path, 'wb') as f:
                pickle.dump(labels, f, protocol=2)

        else:
            # Save coords to pickle
            coord_path = "%s%s" % (namer_dir, '/coords_plotting.pkl')
            with open(coord_path, 'wb') as f:
                pickle.dump(coords, f, protocol=2)

            # Save labels to pickle
            labels_path = "%s%s" % (namer_dir, '/labelnames_plotting.pkl')
            with open(labels_path, 'wb') as f:
                pickle.dump(labels, f, protocol=2)

        connectome = niplot.plot_connectome(np.zeros(shape=(1, 1)), [(0, 0, 0)], node_size=0.0001, black_bg=True)
        connectome.add_overlay(ch2better_loc, alpha=0.45, cmap=plt.cm.gray)
        #connectome.add_overlay(ch2better_loc, alpha=0.35, cmap=plt.cm.gray)
        conn_matrix = np.array(np.array(thresholding.autofix(conn_matrix)))
        [z_min, z_max] = -np.abs(conn_matrix).max(), np.abs(conn_matrix).max()
        if node_size == 'parc':
            node_size_plot = int(6)
        else:
            node_size_plot = int(node_size)
        if len(coords) != conn_matrix.shape[0]:
            raise RuntimeWarning('\nWARNING: Number of coordinates does not match conn_matrix dimensions. If you are '
                                 'using disparity filtering, try relaxing the α threshold.')
        else:
            color_theme = 'Blues'
            #color_theme = 'Greens'
            #color_theme = 'Reds'
            node_color = 'auto'
            connectome.add_graph(conn_matrix, coords, edge_threshold=edge_threshold, edge_cmap=color_theme,
                                 edge_vmax=float(z_max), edge_vmin=float(z_min), node_size=node_size_plot,
                                 node_color='auto')
            connectome.savefig(out_path_fig, dpi=dpi_resolution)
    else:
        raise RuntimeError('\nERROR: no coordinates to plot! Are you running plotting outside of pynets\'s internal '
                           'estimation schemes?')

    plt.close('all')

    return
Esempio n. 5
0
def plot_all(conn_matrix, conn_model, atlas, dir_path, ID, network, labels,
             roi, coords, thr, node_size, edge_threshold, smooth, prune,
             uatlas, c_boot, norm, binary, hpass):
    """

    :param conn_matrix:
    :param conn_model:
    :param atlas:
    :param dir_path:
    :param ID:
    :param network:
    :param labels:
    :param roi:
    :param coords:
    :param thr:
    :param node_size:
    :param edge_threshold:
    :param smooth:
    :param prune:
    :param uatlas:
    :param c_boot:
    :param norm:
    :param binary:
    :param hpass:
    :return:
    """
    import matplotlib
    matplotlib.use('agg')
    from matplotlib import pyplot as plt
    from nilearn import plotting as niplot
    import pkg_resources
    import networkx as nx
    from pynets import plotting, thresholding
    from pynets.plotting import plot_gen, plot_graphs
    from pynets.stats.netstats import most_important, prune_disconnected
    try:
        import cPickle as pickle
    except ImportError:
        import _pickle as pickle

    coords = list(coords)
    labels = list(labels)
    if len(coords) > 0:
        dpi_resolution = 500
        if '\'b' in atlas:
            atlas = atlas.decode('utf-8')
        if (prune == 1 or prune == 2) and len(coords) == conn_matrix.shape[0]:
            G_pre = nx.from_numpy_matrix(conn_matrix)
            if prune == 1:
                [G, pruned_nodes] = prune_disconnected(G_pre)
            elif prune == 2:
                [G, pruned_nodes] = most_important(G_pre)
            else:
                G = G_pre
                pruned_nodes = []
            pruned_nodes.sort(reverse=True)
            print('(Display)')
            coords_pre = list(coords)
            labels_pre = list(labels)
            if len(pruned_nodes) > 0:
                for j in pruned_nodes:
                    labels_pre.pop(j)
                    coords_pre.pop(j)
                conn_matrix = nx.to_numpy_array(G)
                labels = labels_pre
                coords = coords_pre
            else:
                print('No nodes to prune for plot...')

        coords = list(tuple(x) for x in coords)
        # Plot connectogram
        if len(conn_matrix) > 20:
            try:
                plot_gen.plot_connectogram(conn_matrix, conn_model, atlas,
                                           dir_path, ID, network, labels)
            except RuntimeWarning:
                print('\n\n\nWarning: Connectogram plotting failed!')
        else:
            print(
                'Warning: Cannot plot connectogram for graphs smaller than 20 x 20!'
            )

        # Plot adj. matrix based on determined inputs
        if not node_size or node_size == 'None':
            node_size = 'parc'
        plot_graphs.plot_conn_mat_func(conn_matrix, conn_model, atlas,
                                       dir_path, ID, network, labels, roi, thr,
                                       node_size, smooth, c_boot, hpass)

        # Plot connectome
        if roi:
            out_path_fig = "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s" % (
                dir_path, '/', ID, '_', atlas, '_', conn_model, '_',
                op.basename(roi).split('.')[0], "%s" %
                ("%s%s%s" %
                 ('_', network, '_') if network else "_"), thr, '_', node_size,
                '%s' % ("mm_" if node_size != 'parc' else "_"), "%s" %
                ("%s%s" %
                 (int(c_boot), 'nb_') if float(c_boot) > 0 else 'nb_'), "%s" %
                ("%s%s" %
                 (smooth, 'fwhm_') if float(smooth) > 0 else ''), "%s" %
                ("%s%s" % (hpass, 'Hz_') if hpass is not None else ''),
                'func_glass_viz.png')

            # Save coords to pickle
            coord_path = "%s%s%s%s" % (dir_path, '/coords_',
                                       op.basename(roi).split('.')[0],
                                       '_plotting.pkl')
            with open(coord_path, 'wb') as f:
                pickle.dump(coords, f, protocol=2)
            # Save labels to pickle
            labels_path = "%s%s%s%s" % (dir_path, '/labelnames_',
                                        op.basename(roi).split('.')[0],
                                        '_plotting.pkl')
            with open(labels_path, 'wb') as f:
                pickle.dump(labels, f, protocol=2)
        else:
            out_path_fig = "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s" % (
                dir_path, '/', ID, '_', atlas, '_', conn_model, "%s" %
                ("%s%s%s" %
                 ('_', network, '_') if network else "_"), thr, '_', node_size,
                '%s' % ("mm_" if node_size != 'parc' else "_"), "%s" %
                ("%s%s" %
                 (int(c_boot), 'nb_') if float(c_boot) > 0 else 'nb_'), "%s" %
                ("%s%s" %
                 (smooth, 'fwhm_') if float(smooth) > 0 else ''), "%s" %
                ("%s%s" % (hpass, 'Hz_') if hpass is not None else ''),
                'func_glass_viz.png')
            # Save coords to pickle
            coord_path = "%s%s" % (dir_path, '/coords_plotting.pkl')
            with open(coord_path, 'wb') as f:
                pickle.dump(coords, f, protocol=2)
            # Save labels to pickle
            labels_path = "%s%s" % (dir_path, '/labelnames_plotting.pkl')
            with open(labels_path, 'wb') as f:
                pickle.dump(labels, f, protocol=2)

        ch2better_loc = pkg_resources.resource_filename(
            "pynets", "templates/ch2better.nii.gz")
        connectome = niplot.plot_connectome(np.zeros(shape=(1, 1)),
                                            [(0, 0, 0)],
                                            node_size=0.0001,
                                            black_bg=True)
        connectome.add_overlay(ch2better_loc, alpha=0.45, cmap=plt.cm.gray)
        #connectome.add_overlay(ch2better_loc, alpha=0.35, cmap=plt.cm.gray)
        conn_matrix = np.array(np.array(thresholding.autofix(conn_matrix)))
        [z_min, z_max] = -np.abs(conn_matrix).max(), np.abs(conn_matrix).max()
        if node_size == 'parc':
            node_size_plot = int(2)
            if uatlas:
                connectome.add_contours(uatlas,
                                        filled=True,
                                        alpha=0.20,
                                        cmap=plt.cm.gist_rainbow)
        else:
            node_size_plot = int(node_size)
        if len(coords) != conn_matrix.shape[0]:
            raise RuntimeWarning(
                '\nWARNING: Number of coordinates does not match conn_matrix dimensions. If you are '
                'using disparity filtering, try relaxing the α threshold.')
        else:
            color_theme = 'Blues'
            #color_theme = 'Greens'
            #color_theme = 'Reds'
            node_color = 'auto'
            connectome.add_graph(conn_matrix,
                                 coords,
                                 edge_threshold=edge_threshold,
                                 edge_cmap=color_theme,
                                 edge_vmax=float(z_max),
                                 edge_vmin=float(z_min),
                                 node_size=node_size_plot,
                                 node_color='auto')
            connectome.savefig(out_path_fig, dpi=dpi_resolution)
    else:
        raise RuntimeError(
            '\nERROR: no coordinates to plot! Are you running plotting outside of pynets\'s internal '
            'estimation schemes?')
    return
Esempio n. 6
0
def plot_all_func(conn_matrix,
                  conn_model,
                  atlas,
                  dir_path,
                  ID,
                  network,
                  labels,
                  roi,
                  coords,
                  thr,
                  node_size,
                  edge_threshold,
                  smooth,
                  prune,
                  uatlas,
                  norm,
                  binary,
                  hpass,
                  extract_strategy,
                  edge_color_override=False):
    """
    Plot adjacency matrix, connectogram, and glass brain for functional connectome.

    Parameters
    ----------
    conn_matrix : array
        NxN matrix.
    conn_model : str
       Connectivity estimation model (e.g. corr for correlation, cov for covariance, sps for precision covariance,
       partcorr for partial correlation). sps type is used by default.
    atlas : str
        Name of atlas parcellation used.
    dir_path : str
        Path to directory containing subject derivative data for given run.
    ID : str
        A subject id or other unique identifier.
    network : str
        Resting-state network based on Yeo-7 and Yeo-17 naming (e.g. 'Default') used to filter nodes in the study of
        brain subgraphs.
    labels : list
        List of string labels corresponding to ROI nodes.
    roi : str
        File path to binarized/boolean region-of-interest Nifti1Image file.
    coords : list
        List of (x, y, z) tuples corresponding to an a-priori defined set (e.g. a coordinate atlas).
    thr : float
        A value, between 0 and 1, to threshold the graph using any variety of methods
        triggered through other options.
    node_size : int
        Spherical centroid node size in the case that coordinate-based centroids
        are used as ROI's.
    edge_threshold : float
        The actual value, between 0 and 1, that the graph was thresholded (can differ from thr if target was not
        successfully obtained.
    smooth : int
        Smoothing width (mm fwhm) to apply to time-series when extracting signal from ROI's.
    prune : bool
        Indicates whether to prune final graph of disconnected nodes/isolates.
    uatlas : str
        File path to atlas parcellation Nifti1Image in MNI template space.
    norm : int
        Indicates method of normalizing resulting graph.
    binary : bool
        Indicates whether to binarize resulting graph edges to form an
        unweighted graph.
    hpass : bool
        High-pass filter values (Hz) to apply to node-extracted time-series.
    extract_strategy : str
        The name of a valid function used to reduce the time-series region extraction.
    edge_color_override : bool
        Switch that enables random sequential colormap selection for edges.
    """
    import os
    import yaml
    import sys
    import os.path as op
    import random
    import matplotlib
    matplotlib.use('agg')
    from matplotlib import pyplot as plt
    from nilearn import plotting as niplot
    import pkg_resources
    import networkx as nx
    from pynets.plotting import plot_gen, plot_graphs
    from pynets.plotting.plot_gen import create_gb_palette
    try:
        import cPickle as pickle
    except ImportError:
        import _pickle as pickle

    ch2better_loc = pkg_resources.resource_filename(
        "pynets", "templates/ch2better.nii.gz")

    with open(pkg_resources.resource_filename("pynets", "runconfig.yaml"),
              'r') as stream:
        hardcoded_params = yaml.load(stream)
        try:
            if edge_color_override is False:
                color_theme = hardcoded_params['plotting']['functional'][
                    'glassbrain']['color_theme'][0]
            else:
                color_theme = random.choice([
                    'Purples_d', 'Blues_d', 'Greens_d', 'Oranges_d', 'Reds_d',
                    'YlOrBr_d', 'YlOrRd_d', 'OrRd_d', 'PuRd_d', 'RdPu_d',
                    'BuPu_d', 'GnBu_d', 'PuBu_d', 'YlGnBu_d', 'PuBuGn_d',
                    'BuGn_d', 'YlGn_d'
                ])

            connectogram = hardcoded_params['plotting']['connectogram'][0]
            glassbrain = hardcoded_params['plotting']['glassbrain'][0]
            adjacency = hardcoded_params['plotting']['adjacency'][0]
            dpi_resolution = hardcoded_params['plotting']['dpi'][0]
        except KeyError:
            print(
                'ERROR: Plotting configuration not successfully extracted from runconfig.yaml'
            )
            sys.exit(0)
    stream.close()

    if not isinstance(coords, list):
        coords = list(tuple(x) for x in coords)

    if not isinstance(labels, list):
        labels = list(labels)

    if len(coords) > 0:
        if '\'b' in atlas:
            atlas = atlas.decode('utf-8')

        namer_dir = dir_path + '/figures'
        if not os.path.isdir(namer_dir):
            os.makedirs(namer_dir, exist_ok=True)

        # Plot connectogram
        if connectogram is True:
            if len(conn_matrix) > 20:
                try:
                    plot_gen.plot_connectogram(conn_matrix, conn_model, atlas,
                                               namer_dir, ID, network, labels)
                except RuntimeWarning:
                    print('\n\n\nWarning: Connectogram plotting failed!')
            else:
                print(
                    'Warning: Cannot plot connectogram for graphs smaller than 20 x 20!'
                )

        # Plot adj. matrix based on determined inputs
        if not node_size or node_size == 'None':
            node_size = 'parc'

        if adjacency is True:
            plot_graphs.plot_conn_mat_func(conn_matrix, conn_model, atlas,
                                           namer_dir, ID, network, labels, roi,
                                           thr, node_size, smooth, hpass,
                                           extract_strategy)

        if glassbrain is True:
            views = ['x', 'y', 'z']
            # Plot connectome
            out_path_fig = "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s" % (
                namer_dir, '/', ID, '_modality-func_', '%s' %
                ("%s%s%s" %
                 ('rsn-', network, '_') if network is not None else ''), '%s' %
                ("%s%s%s" % ('roi-', op.basename(roi).split('.')[0], '_')
                 if roi is not None else ''), 'est-', conn_model, '_', '%s' %
                ("%s%s%s" % ('nodetype-spheres-', node_size, 'mm_') if
                 ((node_size != 'parc') and
                  (node_size is not None)) else 'nodetype-parc_'), "%s" %
                ("%s%s%s" %
                 ('smooth-', smooth, 'fwhm_') if float(smooth) > 0 else ''),
                "%s" %
                ("%s%s%s" %
                 ('hpass-', hpass, 'Hz_') if hpass is not None else ''), "%s" %
                ("%s%s%s" %
                 ('extract-', extract_strategy, '_') if extract_strategy
                 is not None else ''), '_thr-', thr, '_glass_viz.png')

            connectome = niplot.plot_connectome(np.zeros(shape=(1, 1)),
                                                [(0, 0, 0)],
                                                node_size=0.0001,
                                                black_bg=True)
            connectome.add_overlay(ch2better_loc, alpha=0.45, cmap=plt.cm.gray)
            [
                conn_matrix, clust_pal_edges, clust_pal_nodes, node_sizes,
                edge_sizes, z_min, z_max, coords, labels
            ] = create_gb_palette(conn_matrix, color_theme, coords, labels)

            if roi:
                # Save coords to pickle
                coord_path = f"{namer_dir}{'/coords_'}{op.basename(roi).split('.')[0]}{'_plotting.pkl'}"
                with open(coord_path, 'wb') as f:
                    pickle.dump(coords, f, protocol=2)

                # Save labels to pickle
                labels_path = f"{namer_dir}{'/labelnames_'}{op.basename(roi).split('.')[0]}{'_plotting.pkl'}"
                with open(labels_path, 'wb') as f:
                    pickle.dump(labels, f, protocol=2)

            else:
                # Save coords to pickle
                coord_path = f"{namer_dir}{'/coords_plotting.pkl'}"
                with open(coord_path, 'wb') as f:
                    pickle.dump(coords, f, protocol=2)

                # Save labels to pickle
                labels_path = f"{namer_dir}{'/labelnames_plotting.pkl'}"
                with open(labels_path, 'wb') as f:
                    pickle.dump(labels, f, protocol=2)

            connectome.add_graph(conn_matrix,
                                 coords,
                                 edge_cmap=clust_pal_edges,
                                 edge_vmax=float(z_max),
                                 edge_vmin=float(z_min),
                                 node_size=node_sizes,
                                 node_color=clust_pal_nodes,
                                 edge_kwargs={'alpha': 0.45})
            for view in views:
                mod_lines = []
                for line, edge_size in list(
                        zip(connectome.axes[view].ax.lines, edge_sizes)):
                    line.set_lw(edge_size)
                    mod_lines.append(line)
                connectome.axes[view].ax.lines = mod_lines
            connectome.savefig(out_path_fig, dpi=dpi_resolution)
        else:
            raise RuntimeError(
                '\nERROR: no coordinates to plot! Are you running plotting outside of pynets\'s '
                'internal estimation schemes?')

        plt.close('all')

    return