code: def _get_coord_mapping(
      dims,
      output,
      out_indices,
      numblocks,
      argpairs,
      concatenate,
  ):
      """Calculate coordinate mapping for graph construction.
  
      This function handles the high-level logic behind Blockwise graph
      construction. The output is a tuple containing: The mapping between
      input and output block coordinates (`coord_maps`), the axes along
      which to concatenate for each input (`concat_axes`), and the dummy
      indices needed for broadcasting (`dummies`).
  
      Used by `make_blockwise_graph` and `Blockwise._cull_dependencies`.
  
      Parameters
      ----------
      dims : dict
          Mapping between each index specified in `argpairs` and
          the number of output blocks for that index. Corresponds
          to the Blockwise `dims` attribute.
      output : str
          Corresponds to the Blockwise `output` attribute.
      out_indices : tuple
          Corresponds to the Blockwise `output_indices` attribute.
      numblocks : dict
          Corresponds to the Blockwise `numblocks` attribute.
      argpairs : tuple
          Corresponds to the Blockwise `indices` attribute.
      concatenate : bool
          Corresponds to the Blockwise `concatenate` attribute.
      """
  
      block_names = set()
      all_indices = set()
      for name, ind in argpairs:
          if ind is not None:
              block_names.add(name)
              for x in ind:
                  all_indices.add(x)
      assert set(numblocks) == block_names
  
      dummy_indices = all_indices - set(out_indices)
  
      # For each position in the output space, we'll construct a
      # "coordinate set" that consists of
      # - the output indices
      # - the dummy indices
      # - the dummy indices, with indices replaced by zeros (for broadcasting), we
      #   are careful to only emit a single dummy zero when concatenate=True to not
      #   concatenate the same array with itself several times.
      # - a 0 to assist with broadcasting.
  
      index_pos, zero_pos = {}, {}
      for i, ind in enumerate(out_indices):
          index_pos[ind] = i
          zero_pos[ind] = -1
  
      _dummies_list = []
      for i, ind in enumerate(dummy_indices):
          index_pos[ind] = 2 * i + len(out_indices)
          zero_pos[ind] = 2 * i + 1 + len(out_indices)
          reps = 1 if concatenate else dims[ind]
          _dummies_list.append([list(range(dims[ind])), [0] * reps])
  
      # ([0, 1, 2], [0, 0, 0], ...)  For a dummy index of dimension 3
      dummies = tuple(itertools.chain.from_iterable(_dummies_list))
      dummies += (0,)
  
      # For each coordinate position in each input, gives the position in
      # the coordinate set.
      coord_maps = []
  
      # Axes along which to concatenate, for each input
      concat_axes = []
      for arg, ind in argpairs:
          if ind is not None:
              coord_maps.append(
                  [
                      zero_pos[i] if nb == 1 else index_pos[i]
                      for i, nb in zip(ind, numblocks[arg])
                  ]
              )
              concat_axes.append(
                  [n for n, i in enumerate(ind) if i in dummy_indices]
              )
          else:
              coord_maps.append(None)
              concat_axes.append(None)
  
      return coord_maps, concat_axes, dummies
  
imports: from __future__ import annotations
  import itertools
  import os
  from collections.abc import Hashable, Iterable, Mapping, Sequence
  from itertools import product
  from math import prod
  from typing import Any
  import tlz
  import dask
  from dask.base import clone_key, get_name_from_key, tokenize
  from dask.core import flatten, ishashable, keys_in_tasks, reverse_dict
  from dask.highlevelgraph import HighLevelGraph, Layer
  from dask.optimization import SubgraphCallable, fuse
  from dask.typing import Graph, Key
  from dask.utils import _deprecated, apply, ensure_dict, homogeneous_deepmap, stringify_collection_keys
label_desc: Use image node_id 5 for calling a global function with example usage: _get_coord_mapping(dims, output, out_indices, numblocks, argpairs, concatenate) and returns: coord_maps,  concat_axes,  dummies