docs: def compute_interpolator(self, ikwargs={}):
          """
          Compute/define the interpolating spline. This function can be overriden
          in a subclass to define custom interpolators.
  
          Parameters
          ----------
          ikwargs : dict, optional
  
              Additional optional keyword arguments. Possible values are:
  
              - **degree** : int, tuple, optional
                  Degree of the interpolating spline. A tuple can be used to
                  provide different degrees for the X- and Y-axes.
                  Default value is degree=3.
  
              - **s** : float, optional
                  Non-negative smoothing factor. Default value s=0 corresponds to
                  interpolation.
                  See :py:class:`~scipy.interpolate.RectBivariateSpline` for more
                  details.
  
          Notes
          -----
              * When subclassing :py:class:`FittableImageModel` for the
                purpose of overriding :py:func:`compute_interpolator`,
                the :py:func:`evaluate` may need to overriden as well depending
                on the behavior of the new interpolator. In addition, for
                improved future compatibility, make sure
                that the overriding method stores keyword arguments ``ikwargs``
                by calling ``_store_interpolator_kwargs`` method.
  
              * Use caution when modifying interpolator's degree or smoothness in
                a computationally intensive part of the code as it may decrease
                code performance due to the need to recompute interpolator.
  
          """
          from scipy.interpolate import RectBivariateSpline
  
          if 'degree' in ikwargs:
              degree = ikwargs['degree']
              if hasattr(degree, '__iter__') and len(degree) == 2:
                  degx = int(degree[0])
                  degy = int(degree[1])
              else:
                  degx = int(degree)
                  degy = int(degree)
              if degx < 0 or degy < 0:
                  raise ValueError("Interpolator degree must be a non-negative "
                                   "integer")
          else:
              degx = 3
              degy = 3
  
          if 's' in ikwargs:
              smoothness = ikwargs['s']
          else:
              smoothness = 0
  
          x = np.arange(self._nx, dtype=np.float)
          y = np.arange(self._ny, dtype=np.float)
          self.interpolator = RectBivariateSpline(
              x, y, self._data.T, kx=degx, ky=degy, s=smoothness
          )
  
          self._store_interpolator_kwargs(ikwargs)