code: def plot_connectome(
      adjacency_matrix,
      node_coords,
      node_color="auto",
      node_size=50,
      edge_cmap=cm.bwr,
      edge_vmin=None,
      edge_vmax=None,
      edge_threshold=None,
      output_file=None,
      display_mode="ortho",
      figure=None,
      axes=None,
      title=None,
      annotate=True,
      black_bg=False,
      alpha=0.7,
      edge_kwargs=None,
      node_kwargs=None,
      colorbar=False,
      radiological=False,
  ):
      """Plot connectome on top of the brain glass schematics.
  
      The plotted image should be in :term:`MNI` space for this function to work
      properly.
  
      In the case of 'l' and 'r' directions (for hemispheric projections),
      markers in the coordinate x == 0 are included in both hemispheres.
  
      Parameters
      ----------
      adjacency_matrix : numpy array of shape (n, n)
          Represents the link strengths of the graph. The matrix can be
          symmetric which will result in an undirected graph, or not
          symmetric which will result in a directed graph.
  
      node_coords : numpy array_like of shape (n, 3)
          3d coordinates of the graph nodes in world space.
  
      node_color : color or sequence of colors or 'auto', optional
          Color(s) of the nodes. If string is given, all nodes
          are plotted with same color given in string.
  
      node_size : scalar or array_like, default=50
          Size(s) of the nodes in points^2.
  
      edge_cmap : colormap, default=cm.bwr
          Colormap used for representing the strength of the edges.
  
      edge_vmin, edge_vmax : float, optional
          If not None, either or both of these values will be used to
          as the minimum and maximum values to color edges. If None are
          supplied the maximum absolute value within the given threshold
          will be used as minimum (multiplied by -1) and maximum
          coloring levels.
  
      edge_threshold : str or number, optional
          If it is a number only the edges with a value greater than
          edge_threshold will be shown.
          If it is a string it must finish with a percent sign,
          e.g. "25.3%%", and only the edges with a abs(value) above
          the given percentile will be shown.
      %(output_file)s
      display_mode : string, default='ortho'
          Choose the direction of the cuts: 'x' - sagittal, 'y' - coronal,
          'z' - axial, 'l' - sagittal left hemisphere only,
          'r' - sagittal right hemisphere only, 'ortho' - three cuts are
          performed in orthogonal directions. Possible values are: 'ortho',
          'x', 'y', 'z', 'xz', 'yx', 'yz', 'l', 'r', 'lr', 'lzr', 'lyr',
          'lzry', 'lyrz'.
      %(figure)s
      %(axes)s
      %(title)s
      %(annotate)s
      %(black_bg)s
          Default=False.
      alpha : float between 0 and 1, default=0.7
          Alpha transparency for the brain schematics.
  
      edge_kwargs : dict, optional
          Will be passed as kwargs for each edge matlotlib Line2D.
  
      node_kwargs : dict, optional
          Will be passed as kwargs to the plt.scatter call that plots all
          the nodes in one go.
      %(colorbar)s
          Default=False.
      %(radiological)s
  
      Returns
      -------
      display : :class:`~nilearn.plotting.displays.OrthoProjector` or None
          An instance of the OrthoProjector class. If ``output_file`` is defined,
          None is returned.
  
      See Also
      --------
      nilearn.plotting.find_parcellation_cut_coords : Extraction of node
          coords on brain parcellations.
      nilearn.plotting.find_probabilistic_atlas_cut_coords : Extraction of
          node coords on brain probabilistic atlases.
  
      """
      display = plot_glass_brain(
          None,
          display_mode=display_mode,
          figure=figure,
          axes=axes,
          title=title,
          annotate=annotate,
          black_bg=black_bg,
          alpha=alpha,
          radiological=radiological,
      )
  
      display.add_graph(
          adjacency_matrix,
          node_coords,
          node_color=node_color,
          node_size=node_size,
          edge_cmap=edge_cmap,
          edge_vmin=edge_vmin,
          edge_vmax=edge_vmax,
          edge_threshold=edge_threshold,
          edge_kwargs=edge_kwargs,
          node_kwargs=node_kwargs,
          colorbar=colorbar,
      )
  
      if output_file is not None:
          display.savefig(output_file)
          display.close()
          display = None
  
      return display
  
imports: import collections.abc
  import functools
  import numbers
  import os
  import warnings
  import matplotlib
  import matplotlib.pyplot
  import numpy
  from matplotlib import gridspec
  from matplotlib.colors import LinearSegmentedColormap
  from nibabel.spatialimages import SpatialImage
  from scipy import stats
  from scipy.ndimage import binary_fill_holes
  from nilearn.image.resampling import reorder_img
  from nilearn.maskers import NiftiMasker
  from nilearn.plotting.displays import get_projector, get_slicer
  from nilearn.plotting.displays._slicers import _get_cbar_ticks
  from ..None import _utils
  from .._utils import compare_version, fill_doc
  from .._utils.extmath import fast_abs_percentile
  from .._utils.ndimage import get_border_data
  from .._utils.niimg import safe_get_data
  from .._utils.numpy_conversions import as_ndarray
  from .._utils.param_validation import check_threshold
  from ..datasets import load_mni152_template
  from ..image import get_data, iter_img, math_img, new_img_like, resample_to_img
  from ..masking import apply_mask, compute_epi_mask
  from ..signal import clean
  from .None import cm
label_desc: Use image node_id 14 for calling a global function with example usage: plot_connectome(adjacency_matrix, node_coords, node_color, node_size, edge_cmap, edge_vmin, edge_vmax, edge_threshold, output_file, display_mode, figure, axes, title, annotate, black_bg, alpha, edge_kwargs, node_kwargs, colorbar, radiological) and returns: display