class_docstr: Class for masking of Niimg-like objects using seeds.
  
  NiftiSpheresMasker is useful when data from given seeds should be
  extracted. Use case: Summarize brain signals from seeds that were
  obtained from prior knowledge.
  
  Parameters
  ----------
  seeds : :obj:`list` of triplet of coordinates in native space
      Seed definitions. List of coordinates of the seeds in the same space
      as the images (typically MNI or TAL).
  
  radius : :obj:`float`, default=None
      Indicates, in millimeters, the radius for the sphere around the seed.
      By default signal is extracted on a single voxel.
  
  mask_img : Niimg-like object, default=None
      See :ref:`extracting_data`.
      Mask to apply to regions before extracting signals.
  
  allow_overlap : :obj:`bool`, default=False
      If False, an error is raised if the maps overlaps (ie at least two
      maps have a non-zero value for the same voxel).
  %(smoothing_fwhm)s
  %(standardize_maskers)s
  %(standardize_confounds)s
  high_variance_confounds : :obj:`bool`, default=False
      If True, high variance confounds are computed on provided image with
      :func:`nilearn.image.high_variance_confounds` and default parameters
      and regressed out.
  %(detrend)s
  %(low_pass)s
  %(high_pass)s
  %(t_r)s
  dtype : {dtype, "auto"}, optional
      Data type toward which the data should be converted. If "auto", the
      data will be converted to int32 if dtype is discrete and float32 if it
      is continuous.
  %(memory)s
  %(memory_level1)s
  %(verbose0)s
  %(masker_kwargs)s
  
  Attributes
  ----------
  n_elements_ : :obj:`int`
      The number of seeds in the masker.
  
      .. versionadded:: 0.9.2
  
  seeds_ : :obj:`list` of :obj:`list`
      The coordinates of the seeds in the masker.
  
  reports : boolean, default=True
       If set to True, data is saved in order to produce a report.
  
  See Also
  --------
  nilearn.maskers.NiftiMasker
docstr: Return a list of all displays to be rendered.
  
  Returns
  -------
  displays : list
      A list of all displays to be rendered.
docstr_tok: ["Return","a","list","of","all","displays","to","be","rendered",".","Returns","--","--","--","-","displays",":","list","A","list","of","all","displays","to","be","rendered","."]
code: def _reporting(self):
      """Return a list of all displays to be rendered.
  
      Returns
      -------
      displays : list
          A list of all displays to be rendered.
      """
      from nilearn import plotting
      from nilearn.reporting.html_report import _embed_img
  
      if self._reporting_data is not None:
          seeds = self._reporting_data["seeds"]
      else:
          self._report_content["summary"] = None
  
          return [None]
  
      img = self._reporting_data["img"]
      if img is None:
          img = load_mni152_template()
          positions = seeds
          msg = (
              "No image provided to fit in NiftiSpheresMasker. "
              "Spheres are plotted on top of the MNI152 template."
          )
          warnings.warn(msg)
          self._report_content["warning_message"] = msg
      else:
          positions = [
              np.round(
                  image.resampling.coord_transform(
                      *seed, np.linalg.inv(img.affine)
                  )
              ).astype(int)
              for seed in seeds
          ]
      self._report_content["report_id"] = self.report_id
      self._report_content["number_of_seeds"] = len(seeds)
      spheres_to_be_displayed = range(len(seeds))
      if isinstance(self.displayed_spheres, int):
          if len(seeds) < self.displayed_spheres:
              msg = (
                  "generate_report() received "
                  f"{self.displayed_spheres} spheres to be displayed. "
                  f"But masker only has {len(seeds)} seeds. "
                  "Setting number of displayed spheres "
                  f"to {len(seeds)}."
              )
              warnings.warn(category=UserWarning, message=msg)
              self.displayed_spheres = len(seeds)
          spheres_to_be_displayed = range(self.displayed_spheres)
      elif isinstance(self.displayed_spheres, (list, np.ndarray)):
          if max(self.displayed_spheres) > len(seeds):
              raise ValueError(
                  "Report cannot display the "
                  "following spheres "
                  f"{self.displayed_spheres} because "
                  f"masker only has {len(seeds)} seeds."
              )
          spheres_to_be_displayed = self.displayed_spheres
      self._report_content["displayed_spheres"] = list(
          spheres_to_be_displayed
      )
      columns = [
          "seed number",
          "coordinates",
          "position",
          "radius",
          "size (in mm^3)",
          "size (in voxels)",
          "relative size (in %)",
      ]
      regions_summary = {c: [] for c in columns}
      embeded_images = []
      radius = 1.0 if self.radius is None else self.radius
      display = plotting.plot_markers(
          [1 for _ in seeds],
          seeds,
          node_size=20 * radius,
          colorbar=False,
      )
      embeded_images.append(_embed_img(display))
      display.close()
      for idx, seed in enumerate(seeds):
          regions_summary["seed number"].append(idx)
          regions_summary["coordinates"].append(str(seed))
          regions_summary["position"].append(positions[idx])
          regions_summary["radius"].append(radius)
          regions_summary["size (in voxels)"].append("not implemented")
          regions_summary["size (in mm^3)"].append(
              round(4.0 / 3.0 * np.pi * radius**3, 2)
          )
          regions_summary["relative size (in %)"].append(
              "not implemented"
          )
          if idx in spheres_to_be_displayed:
              display = plotting.plot_img(
                  img, cut_coords=positions[idx]
              )
              display.add_markers(
                  marker_coords=[positions[idx]],
                  marker_color="g",
                  marker_size=20 * radius,
              )
              embeded_images.append(_embed_img(display))
              display.close()
      self._report_content["summary"] = regions_summary
  
      return embeded_images
  
imports: import warnings
  import numpy
  from joblib import Memory
  from scipy import sparse
  from sklearn import neighbors
  from nilearn import image, masking
  from nilearn._utils import CacheMixin, fill_doc, logger
  from nilearn._utils.class_inspect import get_params
  from nilearn._utils.niimg import img_data_dtype
  from nilearn._utils.niimg_conversions import check_niimg_3d, check_niimg_4d, safe_get_data
  from nilearn.datasets import load_mni152_template
  from nilearn.maskers._utils import compute_middle_image
  from nilearn.maskers.base_masker import BaseMasker, _filter_and_extract
label_desc: Use image node_id 3 for calling the NiftiSpheresMasker obj's underlying member method code with example usage: obj._reporting() and returns: embeded_images, list