docs: def get_kde_contour(self, xax="area_um", yax="deform", xacc=None,
                          yacc=None, kde_type="histogram", kde_kwargs={},
                          xscale="linear", yscale="linear"):
          """Evaluate the kernel density estimate for contour plots
  
          Parameters
          ----------
          xax: str
              Identifier for X axis (e.g. "area_um", "aspect", "deform")
          yax: str
              Identifier for Y axis
          xacc: float
              Contour accuracy in x direction
          yacc: float
              Contour accuracy in y direction
          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
          -------
          X, Y, Z : coordinates
              The kernel density Z evaluated on a rectangular grid (X,Y).
          """
          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)
  
          # accuracy (bin width) of KDE estimator
          if xacc is None:
              xacc = kde_methods.bin_width_doane(xs) / 5
          if yacc is None:
              yacc = kde_methods.bin_width_doane(ys) / 5
  
          # Ignore infs and nans
          bad = kde_methods.get_bad_vals(xs, ys)
          xc = xs[~bad]
          yc = ys[~bad]
  
          xnum = int(np.ceil((xc.max() - xc.min()) / xacc))
          ynum = int(np.ceil((yc.max() - yc.min()) / yacc))
  
          xlin = np.linspace(xc.min(), xc.max(), xnum, endpoint=True)
          ylin = np.linspace(yc.min(), yc.max(), ynum, endpoint=True)
  
          xmesh, ymesh = np.meshgrid(xlin, ylin, indexing="ij")
  
          kde_fct = kde_methods.methods[kde_type]
          if len(x):
              density = kde_fct(events_x=xs, events_y=ys,
                                xout=xmesh, yout=ymesh,
                                **kde_kwargs)
          else:
              density = []
  
          # Convert mesh back to linear scale if applicable
          if xscale == "log":
              xmesh = np.exp(xmesh)
          if yscale == "log":
              ymesh = np.exp(ymesh)
  
          return xmesh, ymesh, density