code: def compute_proj_eog(
      raw,
      raw_event=None,
      tmin=-0.2,
      tmax=0.2,
      n_grad=2,
      n_mag=2,
      n_eeg=2,
      l_freq=1.0,
      h_freq=35.0,
      average=True,
      filter_length="10s",
      n_jobs=None,
      reject=dict(grad=2000e-13, mag=3000e-15, eeg=500e-6, eog=np.inf),
      flat=None,
      bads=[],
      avg_ref=False,
      no_proj=False,
      event_id=998,
      eog_l_freq=1,
      eog_h_freq=10,
      tstart=0.0,
      filter_method="fir",
      iir_params=None,
      ch_name=None,
      copy=True,
      return_drop_log=False,
      meg="separate",
      verbose=None,
  ):
      """Compute SSP (signal-space projection) vectors for EOG artifacts.
  
      %(compute_proj_eog)s
  
      .. note:: Raw data must be preloaded.
  
      Parameters
      ----------
      raw : mne.io.Raw
          Raw input file.
      raw_event : mne.io.Raw or None
          Raw file to use for event detection (if None, raw is used).
      tmin : float
          Time before event in seconds.
      tmax : float
          Time after event in seconds.
      n_grad : int
          Number of SSP vectors for gradiometers.
      n_mag : int
          Number of SSP vectors for magnetometers.
      n_eeg : int
          Number of SSP vectors for EEG.
      l_freq : float | None
          Filter low cut-off frequency for the data channels in Hz.
      h_freq : float | None
          Filter high cut-off frequency for the data channels in Hz.
      average : bool
          Compute SSP after averaging. Default is True.
      filter_length : str | int | None
          Number of taps to use for filtering.
      %(n_jobs)s
      reject : dict | None
          Epoch rejection configuration (see Epochs).
      flat : dict | None
          Epoch flat configuration (see Epochs).
      bads : list
          List with (additional) bad channels.
      avg_ref : bool
          Add EEG average reference proj.
      no_proj : bool
          Exclude the SSP projectors currently in the fiff file.
      event_id : int
          ID to use for events.
      eog_l_freq : float
          Low pass frequency applied to the E0G channel for event detection.
      eog_h_freq : float
          High pass frequency applied to the EOG channel for event detection.
      tstart : float
          Start artifact detection after tstart seconds.
      filter_method : str
          Method for filtering ('iir' or 'fir').
      iir_params : dict | None
          Dictionary of parameters to use for IIR filtering.
          See mne.filter.construct_iir_filter for details. If iir_params
          is None and method="iir", 4th order Butterworth will be used.
      ch_name : str | None
          If not None, specify EOG channel name.
      copy : bool
          If False, filtering raw data is done in place. Defaults to True.
      return_drop_log : bool
          If True, return the drop log.
  
          .. versionadded:: 0.15
      meg : str
          Can be 'separate' (default) or 'combined' to compute projectors
          for magnetometers and gradiometers separately or jointly.
          If 'combined', ``n_mag == n_grad`` is required and the number of
          projectors computed for MEG will be ``n_mag``.
  
          .. versionadded:: 0.18
      %(verbose)s
  
      Returns
      -------
      %(projs)s
      eog_events: ndarray
          Detected EOG events.
      drop_log : list
          The drop log, if requested.
  
      See Also
      --------
      find_eog_events
      create_eog_epochs
  
      Notes
      -----
      Filtering is applied to the EOG channel while finding events using
      ``eog_l_freq`` and ``eog_h_freq``, and then to the ``raw`` instance
      using ``l_freq`` and ``h_freq`` before creation of the epochs used to
      create the projectors.
      """
      return _compute_exg_proj(
          "EOG",
          raw,
          raw_event,
          tmin,
          tmax,
          n_grad,
          n_mag,
          n_eeg,
          l_freq,
          h_freq,
          average,
          filter_length,
          n_jobs,
          ch_name,
          reject,
          flat,
          bads,
          avg_ref,
          no_proj,
          event_id,
          eog_l_freq,
          eog_h_freq,
          tstart,
          "auto",
          filter_method,
          iir_params,
          return_drop_log,
          copy,
          meg,
          verbose,
      )
  
file_path: mne-python/mne/preprocessing/ssp.py
imports: import copy
  import numpy
  from .._fiff.pick import pick_types
  from .._fiff.reference import make_eeg_average_ref_proj
  from ..epochs import Epochs
  from ..proj import compute_proj_epochs, compute_proj_evoked
  from ..utils import logger, verbose, warn
  from .ecg import find_ecg_events
  from .eog import find_eog_events
label_desc: Use image node_id 4 for calling a global function with example usage: compute_proj_eog(raw, raw_event, tmin, tmax, n_grad, n_mag, n_eeg, l_freq, h_freq, average, filter_length, n_jobs, reject, flat, bads, avg_ref, no_proj, event_id, eog_l_freq, eog_h_freq, tstart, filter_method, iir_params, ch_name, copy, return_drop_log, meg, verbose) and returns: _compute_exg_proj