code: def get_data(self, element, ranges, style):
      x, y, z = element.dimensions()[:3]
  
      if self.invert_axes:
          x, y = y, x
      cmapper = self._get_colormapper(z, element, ranges, style)
      cmapper = {"field": z.name, "transform": cmapper}
  
      irregular = element.interface.irregular(
          element, x
      ) or element.interface.irregular(element, y)
      if irregular:
          mapping = dict(xs="xs", ys="ys", fill_color=cmapper)
      else:
          mapping = {
              "left": "left",
              "right": "right",
              "fill_color": cmapper,
              "top": "top",
              "bottom": "bottom",
          }
  
      if self.static_source:
          return {}, mapping, style
  
      x, y = dimension_sanitizer(x.name), dimension_sanitizer(y.name)
  
      zdata = element.dimension_values(z, flat=False)
      hover_data = {}
  
      if irregular:
          dims = element.kdims
          if self.invert_axes:
              dims = dims[::-1]
          X, Y = (
              element.interface.coords(
                  element, d, expanded=True, edges=True
              )
              for d in dims
          )
          X, Y = colormesh(X, Y)
          zvals = (
              zdata.T.flatten() if self.invert_axes else zdata.flatten()
          )
          XS, YS = [], []
          mask = []
          xc, yc = [], []
          for xs, ys, zval in zip(X, Y, zvals):
              xs, ys = xs[:-1], ys[:-1]
              if (
                  isfinite(zval)
                  and all(isfinite(xs))
                  and all(isfinite(ys))
              ):
                  XS.append(list(xs))
                  YS.append(list(ys))
                  mask.append(True)
                  if "hover" in self.handles:
                      xc.append(xs.mean())
                      yc.append(ys.mean())
              else:
                  mask.append(False)
          mask = np.array(mask)
  
          data = {"xs": XS, "ys": YS, z.name: zvals[mask]}
          if "hover" in self.handles:
              if not self.static_source:
                  hover_data = self._collect_hover_data(
                      element, mask, irregular=True
                  )
              hover_data[x] = np.array(xc)
              hover_data[y] = np.array(yc)
      else:
          xc, yc = (
              element.interface.coords(
                  element, x, edges=True, ordered=True
              ),
              element.interface.coords(
                  element, y, edges=True, ordered=True
              ),
          )
  
          x0, y0 = cartesian_product([xc[:-1], yc[:-1]], copy=True)
          x1, y1 = cartesian_product([xc[1:], yc[1:]], copy=True)
          zvals = (
              zdata.flatten() if self.invert_axes else zdata.T.flatten()
          )
          data = {
              "left": x0,
              "right": x1,
              dimension_sanitizer(z.name): zvals,
              "bottom": y0,
              "top": y1,
          }
  
          if "hover" in self.handles and not self.static_source:
              hover_data = self._collect_hover_data(element)
              hover_data[x] = element.dimension_values(x)
              hover_data[y] = element.dimension_values(y)
  
      data.update(hover_data)
  
      return data, mapping, style
  
imports: import sys
  import numpy
  import param
  from bokeh.models import CustomJSHover, DatetimeAxis
  from ...core.util import cartesian_product, dimension_sanitizer, isfinite
  from ...element import Raster
  from ..util import categorical_legend
  from .chart import PointPlot
  from .element import ColorbarPlot, LegendPlot
  from .selection import BokehOverlaySelectionDisplay
  from .styles import base_properties, fill_properties, line_properties, mpl_to_bokeh
  from .util import bokeh33, bokeh34, colormesh
label_desc: Use image node_id 1 for calling the QuadMeshPlot obj's underlying member method code with example usage: obj.get_data(element, ranges, style) and returns: data,  mapping,  style, dict,  mapping,  style