code: def summarize_clusters_stc(
      clu,
      p_thresh=0.05,
      tstep=1.0,
      tmin=0,
      subject="fsaverage",
      vertices=None,
  ):
      """Assemble summary SourceEstimate from spatiotemporal cluster results.
  
      This helps visualizing results from spatio-temporal-clustering
      permutation tests.
  
      Parameters
      ----------
      clu : tuple
          The output from clustering permutation tests.
      p_thresh : float
          The significance threshold for inclusion of clusters.
      tstep : float
          The time step between samples of the original :class:`STC
          <mne.SourceEstimate>`, in seconds (i.e., ``1 / stc.sfreq``). Defaults
          to ``1``, which will yield a colormap indicating cluster duration
          measured in *samples* rather than *seconds*.
      tmin : float | int
          The time of the first sample.
      subject : str
          The name of the subject.
      vertices : list of array | instance of SourceSpaces | None
          The vertex numbers associated with the source space locations. Defaults
          to None. If None, equals ``[np.arange(10242), np.arange(10242)]``.
          Can also be an instance of SourceSpaces to get vertex numbers from.
  
          .. versionchanged:: 0.21
             Added support for SourceSpaces.
  
      Returns
      -------
      out : instance of SourceEstimate
          A summary of the clusters. The first time point in this SourceEstimate
          object is the summation of all the clusters. Subsequent time points
          contain each individual cluster. The magnitude of the activity
          corresponds to the duration spanned by the cluster (duration units are
          determined by ``tstep``).
  
          .. versionchanged:: 0.21
             Added support for volume and mixed source estimates.
      """
      _validate_type(vertices, (None, list, SourceSpaces), "vertices")
      if vertices is None:
          vertices = [np.arange(10242), np.arange(10242)]
          klass = SourceEstimate
      elif isinstance(vertices, SourceSpaces):
          klass = dict(
              surface=SourceEstimate,
              volume=VolSourceEstimate,
              mixed=MixedSourceEstimate,
          )[vertices.kind]
          vertices = [s["vertno"] for s in vertices]
      else:
          klass = {1: VolSourceEstimate, 2: SourceEstimate}.get(
              len(vertices), MixedSourceEstimate
          )
      n_vertices_need = sum(len(v) for v in vertices)
  
      t_obs, clusters, clu_pvals, _ = clu
      n_times, n_vertices = t_obs.shape
      if n_vertices != n_vertices_need:
          raise ValueError(
              f"Number of cluster vertices ({n_vertices}) did not match the "
              f"provided vertices ({n_vertices_need})"
          )
      good_cluster_inds = np.where(clu_pvals < p_thresh)[0]
  
      #  Build a convenient representation of each cluster, where each
      #  cluster becomes a "time point" in the SourceEstimate
      if len(good_cluster_inds) == 0:
          raise RuntimeError(
              "No significant clusters available. Please adjust "
              "your threshold or check your statistical "
              "analysis."
          )
      data = np.zeros((n_vertices, n_times))
      data_summary = np.zeros((n_vertices, len(good_cluster_inds) + 1))
      for ii, cluster_ind in enumerate(good_cluster_inds):
          data.fill(0)
          t_inds, v_inds = clusters[cluster_ind]
          data[v_inds, t_inds] = t_obs[t_inds, v_inds]
          # Store a nice visualization of the cluster by summing across time
          data_summary[:, ii + 1] = np.sum(
              _sum_cluster_data(data, tstep), axis=1
          )
          # Make the first "time point" a sum across all clusters for easy
          # visualization
      data_summary[:, 0] = np.sum(data_summary, axis=1)
  
      return klass(data_summary, vertices, tmin, tstep, subject)
  
imports: import numpy
  from scipy import ndimage, sparse
  from scipy.sparse.csgraph import connected_components
  from scipy.stats import f
  from scipy.stats import t
  from ..fixes import has_numba, jit
  from ..parallel import parallel_func
  from ..source_estimate import MixedSourceEstimate, SourceEstimate, VolSourceEstimate
  from ..source_space import SourceSpaces
  from ..utils import ProgressBar, _check_option, _pl, _validate_type, check_random_state, logger, split_list, verbose, warn
  from .parametric import f_oneway, ttest_1samp_no_p
label_desc: Use image node_id 33 for calling a global function with example usage: summarize_clusters_stc(clu, p_thresh, tstep, tmin, subject, vertices) and returns: klass