code: def get_data(self, element, ranges, style):
      # dimension labels
      dim_labels = element.dimensions(label=True)[:3]
      x, y, z = (dimension_sanitizer(d) for d in dim_labels)
  
      if self.invert_axes:
          x, y = y, x
  
      # get raw values
      aggregate = element.gridded
      xvals = aggregate.dimension_values(x, expanded=False)
      yvals = aggregate.dimension_values(y, expanded=False)
      zvals = aggregate.dimension_values(2, flat=False)
  
      # pretty print x and y dimension values if necessary
      def _pprint(dim_label, vals):
          if vals.dtype.kind not in "SU":
              dim = aggregate.get_dimension(dim_label)
              return [dim.pprint_value(v) for v in vals]
  
          return vals
  
      xvals = _pprint(x, xvals)
      yvals = _pprint(y, yvals)
  
      # annular wedges
      start_angle = self.start_angle
      end_angle = self.start_angle + 2 * np.pi
      bins_segment = np.linspace(start_angle, end_angle, len(xvals) + 1)
      segment_ticks = self._map_order_to_ticks(
          start_angle, end_angle, xvals, True
      )
  
      radius_max = 0.5
      radius_min = radius_max * self.radius_inner
      bins_annular = np.linspace(radius_min, radius_max, len(yvals) + 1)
      radius_ticks = self._map_order_to_ticks(
          radius_min, radius_max, yvals
      )
  
      patches = []
      for j in range(len(yvals)):
          ybin = bins_annular[j : j + 2]
          for i in range(len(xvals))[::-1]:
              xbin = np.rad2deg(bins_segment[i : i + 2])
              width = ybin[1] - ybin[0]
              wedge = Wedge(
                  (0.5, 0.5), ybin[1], xbin[0], xbin[1], width=width
              )
              patches.append(wedge)
  
      angles = self._get_markers(segment_ticks, self.xmarks)
      xmarks = self._compute_separations(radius_min, radius_max, angles)
      radii = self._get_markers(radius_ticks, self.ymarks)
      ymarks = [Circle((0.5, 0.5), r) for r in radii]
  
      style["array"] = zvals.flatten()
      self._norm_kwargs(element, ranges, style, element.vdims[0])
      if "vmin" in style:
          style["clim"] = style.pop("vmin"), style.pop("vmax")
  
      data = {
          "annular": patches,
          "xseparator": xmarks,
          "yseparator": ymarks,
      }
      xticks = self._get_ticks(segment_ticks, self.xticks)
      if not isinstance(self.xticks, int):
          xticks = [(v - ((np.pi) / len(xticks)), l) for v, l in xticks]
      yticks = self._get_ticks(radius_ticks, self.yticks)
      ticks = {"xticks": xticks, "yticks": yticks}
      return data, style, ticks
  
imports: from itertools import product
  import numpy
  import param
  from matplotlib.collections import LineCollection, PatchCollection
  from matplotlib.patches import Circle, Wedge
  from ...core.data import GridInterface
  from ...core.spaces import HoloMap
  from ...core.util import dimension_sanitizer, is_nan
  from ..mixins import HeatMapMixin
  from .element import ColorbarPlot
  from .raster import QuadMeshPlot
  from .util import filter_styles
label_desc: Use image node_id 6 for calling the RadialHeatMapPlot obj's underlying member method code with example usage: obj.get_data(element, ranges, style) and returns: data,  style,  ticks, vals, unknown