docs: def _calc_bkg_bkgrms(self):
          """
          Calculate the background and background RMS estimate in each of
          the meshes.
  
          Both meshes are computed at the same time here method because
          the filtering of both depends on the background mesh.
  
          The ``background_mesh`` and ``background_rms_mesh`` images are
          equivalent to the low-resolution "MINIBACKGROUND" and
          "MINIBACK_RMS" background maps in SExtractor, respectively.
          """
  
          if self.sigma_clip is not None:
              data_sigclip = self.sigma_clip(self._mesh_data, axis=1)
          else:
              data_sigclip = self._mesh_data
          del self._mesh_data
  
          # preform mesh rejection on sigma-clipped data (i.e. for any
          # newly-masked pixels)
          idx = self._select_meshes(data_sigclip)
          self.mesh_idx = self.mesh_idx[idx]    # indices for the output mesh
          self._data_sigclip = data_sigclip[idx]    # always a 2D masked array
  
          self._mesh_shape = (self.nyboxes, self.nxboxes)
          self.mesh_yidx, self.mesh_xidx = np.unravel_index(self.mesh_idx,
                                                            self._mesh_shape)
  
          # These properties are needed later to calculate
          # background_mesh_ma and background_rms_mesh_ma.  Note that _bkg1d
          # and _bkgrms1d are masked arrays, but the mask should always be
          # False.
          self._bkg1d = self.bkg_estimator(self._data_sigclip, axis=1)
          self._bkgrms1d = self.bkgrms_estimator(self._data_sigclip, axis=1)
  
          # make the unfiltered 2D mesh arrays (these are not masked)
          if len(self._bkg1d) == self.nboxes:
              bkg = self._make_2d_array(self._bkg1d)
              bkgrms = self._make_2d_array(self._bkgrms1d)
          else:
              bkg = self._interpolate_meshes(self._bkg1d)
              bkgrms = self._interpolate_meshes(self._bkgrms1d)
  
          self._background_mesh_unfiltered = bkg
          self._background_rms_mesh_unfiltered = bkgrms
          self.background_mesh = bkg
          self.background_rms_mesh = bkgrms
  
          # filter the 2D mesh arrays
          if not np.array_equal(self.filter_size, [1, 1]):
              self._filter_meshes()
  
          return