code: def tfr_stockwell(
      inst,
      fmin=None,
      fmax=None,
      n_fft=None,
      width=1.0,
      decim=1,
      return_itc=False,
      n_jobs=None,
      verbose=None,
  ):
      """Compute Time-Frequency Representation (TFR) using Stockwell Transform.
  
      Same computation as `~mne.time_frequency.tfr_array_stockwell`, but operates
      on `~mne.Epochs` objects instead of :class:`NumPy arrays <numpy.ndarray>`.
  
      See :footcite:`Stockwell2007,MoukademEtAl2014,WheatEtAl2010,JonesEtAl2006`
      for more information.
  
      Parameters
      ----------
      inst : Epochs | Evoked
          The epochs or evoked object.
      fmin : None, float
          The minimum frequency to include. If None defaults to the minimum fft
          frequency greater than zero.
      fmax : None, float
          The maximum frequency to include. If None defaults to the maximum fft.
      n_fft : int | None
          The length of the windows used for FFT. If None, it defaults to the
          next power of 2 larger than the signal length.
      width : float
          The width of the Gaussian window. If < 1, increased temporal
          resolution, if > 1, increased frequency resolution. Defaults to 1.
          (classical S-Transform).
      decim : int
          The decimation factor on the time axis. To reduce memory usage.
      return_itc : bool
          Return intertrial coherence (ITC) as well as averaged power.
      n_jobs : int
          The number of jobs to run in parallel (over channels).
      %(verbose)s
  
      Returns
      -------
      power : AverageTFR
          The averaged power.
      itc : AverageTFR
          The intertrial coherence. Only returned if return_itc is True.
  
      See Also
      --------
      mne.time_frequency.tfr_array_stockwell
      mne.time_frequency.tfr_multitaper
      mne.time_frequency.tfr_array_multitaper
      mne.time_frequency.tfr_morlet
      mne.time_frequency.tfr_array_morlet
  
      Notes
      -----
      .. versionadded:: 0.9.0
  
      References
      ----------
      .. footbibliography::
      """
      # verbose dec is used b/c subfunctions are verbose
      data = _get_data(inst, return_itc)
      picks = _pick_data_channels(inst.info)
      info = pick_info(inst.info, picks)
      data = data[:, picks, :]
      power, itc, freqs = tfr_array_stockwell(
          data,
          sfreq=info["sfreq"],
          fmin=fmin,
          fmax=fmax,
          n_fft=n_fft,
          width=width,
          decim=decim,
          return_itc=return_itc,
          n_jobs=n_jobs,
      )
      times = inst.times[::decim].copy()
      nave = len(data)
      out = AverageTFR(
          info, power, times, freqs, nave, method="stockwell-power"
      )
      if return_itc:
          out = (
              out,
              AverageTFR(
                  deepcopy(info),
                  itc,
                  times.copy(),
                  freqs.copy(),
                  nave,
                  method="stockwell-itc",
              ),
          )
      return out
  
file_path: mne-python/mne/time_frequency/_stockwell.py
imports: from copy import deepcopy
  import numpy
  from scipy.fft import fft, fftfreq, ifft
  from .._fiff.pick import _pick_data_channels, pick_info
  from ..parallel import parallel_func
  from ..utils import _validate_type, fill_doc, logger, verbose
  from .tfr import AverageTFR, _get_data
label_desc: Use image node_id 6 for calling a global function with example usage: tfr_stockwell(inst, fmin, fmax, n_fft, width, decim, return_itc, n_jobs, verbose) and returns: out