code: def get_data(self, element, ranges, style):
      x, y, z = (
          dimension_sanitizer(d)
          for d in element.dimensions(label=True)[:3]
      )
      if self.invert_axes:
          x, y = y, x
      cmapper = self._get_colormapper(
          element.vdims[0], element, ranges, style
      )
      if "line_alpha" not in style and "line_width" not in style:
          style["line_alpha"] = 0
          style["selection_line_alpha"] = 0
          style["nonselection_line_alpha"] = 0
      elif "line_color" not in style:
          style["line_color"] = "white"
  
      if not element._unique:
          self.param.warning(
              "HeatMap element index is not unique,  ensure you "
              "aggregate the data before displaying it, e.g. "
              "using heatmap.aggregate(function=np.mean). "
              "Duplicate index values have been dropped."
          )
  
      if self.static_source:
          return (
              {},
              {
                  "x": x,
                  "y": y,
                  "fill_color": {
                      "field": "zvalues",
                      "transform": cmapper,
                  },
              },
              style,
          )
  
      aggregate = element.gridded
      xdim, ydim = aggregate.dimensions()[:2]
  
      xtype = aggregate.interface.dtype(aggregate, xdim)
      widths = None
      if xtype.kind in "SUO":
          xvals = aggregate.dimension_values(xdim)
          width = 1
      else:
          xvals = aggregate.dimension_values(xdim, flat=False)
          if xvals.shape[1] > 1:
              edges = GridInterface._infer_interval_breaks(
                  xvals, axis=1
              )
              widths = np.diff(edges, axis=1).T.flatten()
          else:
              widths = (
                  [self.default_span] * xvals.shape[0]
                  if len(xvals)
                  else []
              )
          xvals = xvals.T.flatten()
          width = "width"
  
      ytype = aggregate.interface.dtype(aggregate, ydim)
      heights = None
      if ytype.kind in "SUO":
          yvals = aggregate.dimension_values(ydim)
          height = 1
      else:
          yvals = aggregate.dimension_values(ydim, flat=False)
          if yvals.shape[0] > 1:
              edges = GridInterface._infer_interval_breaks(
                  yvals, axis=0
              )
              heights = np.diff(edges, axis=0).T.flatten()
          else:
              heights = (
                  [self.default_span] * yvals.shape[1]
                  if len(yvals)
                  else []
              )
          yvals = yvals.T.flatten()
          height = "height"
  
      zvals = aggregate.dimension_values(2, flat=False)
      zvals = zvals.T.flatten()
  
      if self.invert_axes:
          width, height = height, width
  
      data = {x: xvals, y: yvals, "zvalues": zvals}
      if widths is not None:
          data["width"] = widths
      if heights is not None:
          data["height"] = heights
  
      if "hover" in self.handles and not self.static_source:
          for vdim in element.vdims:
              sanitized = dimension_sanitizer(vdim.name)
              data[sanitized] = [
                  "-" if is_nan(v) else vdim.pprint_value(v)
                  for v in aggregate.dimension_values(vdim)
              ]
  
      # Filter radial heatmap options
      style = {
          k: v
          for k, v in style.items()
          if not any(
              g in k for g in RadialHeatMapPlot._style_groups.values()
          )
      }
      return (
          data,
          {
              "x": x,
              "y": y,
              "fill_color": {"field": "zvalues", "transform": cmapper},
              "height": height,
              "width": width,
          },
          style,
      )
  
imports: import numpy
  import param
  from bokeh.models.glyphs import AnnularWedge
  from ...core.data import GridInterface
  from ...core.spaces import HoloMap
  from ...core.util import dimension_sanitizer, is_nan
  from .element import ColorbarPlot, CompositeElementPlot
  from .selection import BokehOverlaySelectionDisplay
  from .styles import base_properties, fill_properties, line_properties, text_properties
label_desc: Use image node_id 4 for calling the HeatMapPlot obj's underlying member method code with example usage: obj.get_data(element, ranges, style) and returns: data,  dict,  style, dict,  dict,  style