docs: def get_kde_scatter(self, xax="area_um", yax="deform", positions=None,
                          kde_type="histogram", kde_kwargs={}, xscale="linear",
                          yscale="linear"):
          """Evaluate the kernel density estimate for scatter plots
  
          Parameters
          ----------
          xax: str
              Identifier for X axis (e.g. "area_um", "aspect", "deform")
          yax: str
              Identifier for Y axis
          positions: list of two 1d ndarrays or ndarray of shape (2, N)
              The positions where the KDE will be computed. Note that
              the KDE estimate is computed from the the points that
              are set in `self.filter.all`.
          kde_type: str
              The KDE method to use
          kde_kwargs: dict
              Additional keyword arguments to the KDE method
          xscale: str
              If set to "log", take the logarithm of the x-values before
              computing the KDE. This is useful when data are are
              displayed on a log-scale. Defaults to "linear".
          yscale: str
              See `xscale`.
  
          Returns
          -------
          density : 1d ndarray
              The kernel density evaluated for the filtered data points.
          """
          xax = xax.lower()
          yax = yax.lower()
          kde_type = kde_type.lower()
          if kde_type not in kde_methods.methods:
              raise ValueError("Not a valid kde type: {}!".format(kde_type))
  
          # Get data
          x = self[xax][self.filter.all]
          y = self[yax][self.filter.all]
  
          # Apply scale (no change for linear scale)
          xs = self._apply_scale(x, xscale, xax)
          ys = self._apply_scale(y, yscale, yax)
  
          if positions is None:
              posx = None
              posy = None
          else:
              posx = self._apply_scale(positions[0], xscale, xax)
              posy = self._apply_scale(positions[1], yscale, yax)
  
          kde_fct = kde_methods.methods[kde_type]
          if len(x):
              density = kde_fct(events_x=xs, events_y=ys,
                                xout=posx, yout=posy,
                                **kde_kwargs)
          else:
              density = []
  
          return density