class_docstr: Artist for an igraph.Graph object.
  
  @param graph: An igraph.Graph object to plot
  @param layout: A layout object or matrix of coordinates to use for plotting.
      Each element or row should describes the coordinates for a vertex.
  @param vertex_style: A dictionary specifying style options for vertices.
  @param edge_style: A dictionary specifying style options for edges.
class_docstr_tok: ["Artist","for","an","igraph.Graph","object",".","@","param","graph",":","An","igraph.Graph","object","to","plot","@","param","layout",":","A","layout","object","or","matrix","of","coordinates","to","use","for","plotting",".","Each","element","or","row","should","describes","the","coordinates","for","a","vertex",".","@","param","vertex_style",":","A","dictionary","specifying","style","options","for","vertices",".","@","param","edge_style",":","A","dictionary","specifying","style","options","for","edges","."]
docstr: Draw the highlighted vertex groups, if requested
docstr_tok: ["Draw","the","highlighted","vertex","groups",",","if","requested"]
code: def _draw_groups(self):
      """Draw the highlighted vertex groups, if requested"""
      # Deferred import to avoid a cycle in the import graph
      from igraph.clustering import VertexClustering, VertexCover
  
      mark_groups = self.kwds["mark_groups"]
      if not mark_groups:
          return
  
      kwds = self.kwds
      palette = self.kwds["palette"]
      layout = self.kwds["layout"]
      vertex_builder = self._vertex_builder
  
      # Figure out what to do with mark_groups in order to be able to
      # iterate over it and get memberlist-color pairs
      if isinstance(mark_groups, dict):
          # Dictionary mapping vertex indices or tuples of vertex
          # indices to colors
          group_iter = iter(mark_groups.items())
      elif isinstance(mark_groups, (VertexClustering, VertexCover)):
          # Vertex clustering
          group_iter = (
              (group, color) for color, group in enumerate(mark_groups)
          )
      elif hasattr(mark_groups, "__iter__"):
          # One-off generators: we need to store the actual list for future
          # calls (e.g. resizing, recoloring, etc.). If we don't do this,
          # the generator is exhausted: we cannot rewind it.
          self.mark_groups = mark_groups = list(mark_groups)
          # Lists, tuples, iterators etc
          group_iter = iter(mark_groups)
      else:
          # False
          group_iter = iter({}.items())
  
      if kwds.get("legend", False):
          legend_info = {
              "handles": [],
              "labels": [],
          }
  
      # Iterate over color-memberlist pairs
      polygons = []
      corner_radii = []
      facecolors = []
      edgecolors = []
      for group, color_id in group_iter:
          if not group or color_id is None:
              continue
  
          color = palette.get(color_id)
  
          if isinstance(group, VertexSeq):
              group = [vertex.index for vertex in group]
          if not hasattr(group, "__iter__"):
              raise TypeError("group membership list must be iterable")
  
          # Get the vertex indices that constitute the convex hull
          hull = [
              group[i]
              for i in convex_hull([layout[idx] for idx in group])
          ]
  
          # Construct the hull polygon
          polygon = [layout[idx] for idx in hull]
  
          # Calculate rounding radius and facecolor
          corner_radius = 1.25 * max(
              vertex_builder[idx].size for idx in hull
          )
          facecolor = (color[0], color[1], color[2], 0.25 * color[3])
  
          if kwds.get("legend", False):
              legend_info["handles"].append(
                  plt.Rectangle(
                      (0, 0),
                      0,
                      0,
                      facecolor=facecolor,
                      edgecolor=color,
                  )
              )
              legend_info["labels"].append(str(color_id))
  
          if len(polygon) >= 1:
              polygons.append(mpl.path.Path(polygon))
              corner_radii.append(corner_radius)
              facecolors.append(facecolor)
              edgecolors.append(color)
  
      art = HullCollection(
          polygons,
          corner_radius=corner_radii,
          facecolor=facecolors,
          edgecolor=edgecolors,
          transform=self.axes.transData,
      )
      self._groups = art
  
      if kwds.get("legend", False):
          self.legend_info = legend_info
  
imports: from warnings import warn
  from functools import wraps, partial
  from igraph._igraph import convex_hull, VertexSeq
  from igraph.drawing.baseclasses import AbstractGraphDrawer
  from igraph.drawing.utils import FakeModule
  from .edge import MatplotlibEdgeDrawer, EdgeCollection
  from .polygon import HullCollection
  from .utils import find_matplotlib
  from .vertex import MatplotlibVertexDrawer, VertexCollection
label_desc: Use image node_id 14 for calling the GraphArtist obj's underlying member method code with example usage: obj._draw_groups() without return types