code: def plot_markers(
      node_values,
      node_coords,
      node_size="auto",
      node_cmap=plt.cm.viridis_r,
      node_vmin=None,
      node_vmax=None,
      node_threshold=None,
      alpha=0.7,
      output_file=None,
      display_mode="ortho",
      figure=None,
      axes=None,
      title=None,
      annotate=True,
      black_bg=False,
      node_kwargs=None,
      colorbar=True,
      radiological=False,
  ):
      """Plot network nodes (markers) on top of the brain glass schematics.
  
      Nodes are color coded according to provided nodal measure. Nodal measure
      usually represents some notion of node importance.
  
      Parameters
      ----------
      node_values : array_like of length n
          Vector containing nodal importance measure. Each node will be colored
          according to corresponding node value.
  
      node_coords : numpy array_like of shape (n, 3)
          3d coordinates of the graph nodes in world space.
  
      node_size : 'auto' or scalar or array-like, optional
          Size(s) of the nodes in points^2. By default the size of the node is
          inversely proportional to the number of nodes.
  
      node_cmap : str or colormap, default=plt.cm.viridis_r.
          Colormap used to represent the node measure.
  
      node_vmin : float, optional
          Lower bound of the colormap. If `None`, the min of the node_values is
          used.
  
      node_vmax : float, optional
          Upper bound of the colormap. If `None`, the min of the node_values is
          used.
  
      node_threshold : float
          If provided only the nodes with a value greater than node_threshold
          will be shown.
  
      alpha : float between 0 and 1, default=0.7
          Alpha transparency for markers.
      %(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.
      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=True.
      %(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.
      """
      node_values = np.array(node_values).flatten()
      node_coords = np.array(node_coords)
  
      # Validate node_values
      if node_values.shape != (node_coords.shape[0],):
          msg = (
              "Dimension mismatch: 'node_values' should be vector of length "
              f"{len(node_coords)}, "
              f"but current shape is {node_values.shape} "
              f"instead of {(node_coords.shape[0], )}"
          )
          raise ValueError(msg)
  
      display = plot_glass_brain(
          None,
          display_mode=display_mode,
          figure=figure,
          axes=axes,
          title=title,
          annotate=annotate,
          black_bg=black_bg,
          radiological=radiological,
      )
  
      if isinstance(node_size, str) and node_size == "auto":
          node_size = min(1e4 / len(node_coords), 100)
  
      # Filter out nodes with node values below threshold
      if node_threshold is not None:
          if node_threshold > np.max(node_values):
              msg = (
                  f"Provided 'node_threshold' value: {node_threshold} "
                  "should not exceed "
                  f"highest node value: {np.max(node_values)}"
              )
              raise ValueError(msg)
  
          retained_nodes = node_values > node_threshold
          node_values = node_values[retained_nodes]
          node_coords = node_coords[retained_nodes]
          if isinstance(node_size, collections.abc.Iterable):
              node_size = [
                  size
                  for ok_retain, size in zip(retained_nodes, node_size)
                  if ok_retain
              ]
  
      # Calculate node colors based on value
      node_vmin = (
          np.min(node_values) if node_vmin is None else node_vmin
      )
      node_vmax = (
          np.max(node_values) if node_vmax is None else node_vmax
      )
      if node_vmin == node_vmax:
          node_vmin = 0.9 * node_vmin
          node_vmax = 1.1 * node_vmax
      norm = matplotlib.colors.Normalize(vmin=node_vmin, vmax=node_vmax)
      node_cmap = (
          plt.get_cmap(node_cmap)
          if isinstance(node_cmap, str)
          else node_cmap
      )
      node_color = [
          node_cmap(norm(node_value)) for node_value in node_values
      ]
  
      # Prepare additional parameters for plt.scatter
      node_kwargs = {} if node_kwargs is None else node_kwargs
      node_kwargs.update([("alpha", alpha)])
  
      display.add_markers(
          marker_coords=node_coords,
          marker_color=node_color,
          marker_size=node_size,
          **node_kwargs,
      )
  
      if colorbar:
          display._colorbar = True
          display._show_colorbar(cmap=node_cmap, norm=norm)
  
      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 15 for calling a global function with example usage: plot_markers(node_values, node_coords, node_size, node_cmap, node_vmin, node_vmax, node_threshold, alpha, output_file, display_mode, figure, axes, title, annotate, black_bg, node_kwargs, colorbar, radiological) and returns: display