code: def test_project_sensors_onto_inflated(tmp_path):
      """Test projecting sEEG sensors onto an inflated brain surface."""
      pytest.importorskip("nibabel")
      raw = mne.io.read_raw_fif(fname_raw)
      trans = _get_trans(fname_trans)[0]
      for subject in ("sample", "fsaverage"):
          os.makedirs(tmp_path / subject / "surf", exist_ok=True)
          for hemi in ("lh", "rh"):
              # fake white surface for pial
              copyfile(
                  subjects_dir / subject / "surf" / f"{hemi}.white",
                  tmp_path / subject / "surf" / f"{hemi}.pial",
              )
              copyfile(
                  subjects_dir / subject / "surf" / f"{hemi}.curv",
                  tmp_path / subject / "surf" / f"{hemi}.curv",
              )
              copyfile(
                  subjects_dir / subject / "surf" / f"{hemi}.inflated",
                  tmp_path / subject / "surf" / f"{hemi}.inflated",
              )
              if subject == "fsaverage":
                  copyfile(
                      subjects_dir
                      / subject
                      / "surf"
                      / f"{hemi}.cortex.patch.flat",
                      tmp_path
                      / subject
                      / "surf"
                      / f"{hemi}.cortex.patch.flat",
                  )
                  copyfile(
                      subjects_dir
                      / subject
                      / "surf"
                      / f"{hemi}.sphere",
                      tmp_path / subject / "surf" / f"{hemi}.sphere",
                  )
      # now make realistic sEEG locations, picked from T1
      raw.pick("eeg")
      raw.load_data()
      raw.set_eeg_reference([])
      raw.set_channel_types({ch: "seeg" for ch in raw.ch_names})
      pos = (
          np.array(
              [
                  [25.85, 9.04, -5.38],
                  [33.56, 9.04, -5.63],
                  [40.44, 9.04, -5.06],
                  [46.75, 9.04, -6.78],
                  [-30.08, 9.04, 28.23],
                  [-32.95, 9.04, 37.99],
                  [-36.39, 9.04, 46.03],
              ]
          )
          / 1000
      )
      raw.drop_channels(raw.ch_names[len(pos) :])
      raw.set_montage(
          mne.channels.make_dig_montage(
              ch_pos=dict(zip(raw.ch_names, pos)), coord_frame="head"
          )
      )
      proj_info = _project_sensors_onto_inflated(
          raw.info, trans, "sample", subjects_dir=tmp_path
      )
      assert_allclose(
          proj_info["chs"][0]["loc"][:3],
          np.array([0.0555809, 0.0034069, -0.04593032]),
          rtol=0.01,
      )
      # check all on inflated surface
      x_dir = np.array([1.0, 0.0, 0.0])
      head_mri_t = mne.transforms.invert_transform(
          trans
      )  # need head->mri
      for hemi in ("lh", "rh"):
          coords, faces = mne.surface.read_surface(
              tmp_path / "sample" / "surf" / f"{hemi}.inflated"
          )
          x_ = coords @ x_dir
          coords -= (
              np.max(x_) * x_dir if hemi == "lh" else np.min(x_) * x_dir
          )
          coords /= 1000  # mm -> m
          for ch in proj_info["chs"]:
              loc = ch["loc"][:3]
              if not np.isnan(loc).any() and (loc[0] <= 0) == (
                  hemi == "lh"
              ):
                  assert (
                      np.linalg.norm(
                          coords
                          - mne.transforms.apply_trans(head_mri_t, loc),
                          axis=1,
                      ).min()
                      < 1e-16
                  )
  
      # test flat map
      montage = raw.get_montage()
      montage.apply_trans(mne.transforms.invert_transform(trans))
      mri_mni_t = mne.read_talxfm("sample", subjects_dir)
      montage.apply_trans(mri_mni_t)  # mri to mni_tal (MNI Taliarach)
      montage.apply_trans(
          mne.transforms.Transform(
              fro="mni_tal", to="mri", trans=np.eye(4)
          )
      )
      raw.set_montage(montage)
      trans = mne.channels.compute_native_head_t(montage)
  
      flat_proj_info = _project_sensors_onto_inflated(
          raw.info,
          trans=trans,
          subject="fsaverage",
          subjects_dir=tmp_path,
          flat=True,
      )
  
      # check all on flat surface
      x_dir = np.array([1.0, 0.0, 0.0])
      head_mri_t = mne.transforms.invert_transform(
          trans
      )  # need head->mri
      for hemi in ("lh", "rh"):
          coords, faces, _ = mne.surface._read_patch(
              tmp_path
              / "fsaverage"
              / "surf"
              / f"{hemi}.cortex.patch.flat"
          )
          coords = coords[:, [1, 0, 2]]
          coords[:, 1] *= -1
          x_ = coords @ x_dir
          coords -= (
              np.max(x_) * x_dir if hemi == "lh" else np.min(x_) * x_dir
          )
          coords /= 1000  # mm -> m
          for ch in flat_proj_info["chs"]:
              loc = ch["loc"][:3]
              if not np.isnan(loc).any() and (loc[0] <= 0) == (
                  hemi == "lh"
              ):
                  assert (
                      np.linalg.norm(
                          coords
                          - mne.transforms.apply_trans(head_mri_t, loc),
                          axis=1,
                      ).min()
                      < 1e-16
                  )
  
file_path: mne-python/mne/preprocessing/ieeg/tests/test_projection.py
imports: import os
  from shutil import copyfile
  import numpy
  import pytest
  from numpy.testing import assert_allclose
  import mne
  from mne.datasets import testing
  from mne.preprocessing.ieeg import project_sensors_onto_brain
  from mne.preprocessing.ieeg._projection import _project_sensors_onto_inflated
  from mne.transforms import _get_trans
label_desc: Use image node_id 2 for calling a global function with example usage: test_project_sensors_onto_inflated(tmp_path) without return types