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: Prepare artist and children for the actual drawing.
  
  Children are not drawn here, but the dictionaries of properties are
  marshalled to their specific artists.
docstr_tok: ["Prepare","artist","and","children","for","the","actual","drawing",".","Children","are","not","drawn","here",",","but","the","dictionaries","of","properties","are","marshalled","to","their","specific","artists","."]
code: def _reprocess(self):
      """Prepare artist and children for the actual drawing.
  
      Children are not drawn here, but the dictionaries of properties are
      marshalled to their specific artists.
      """
      # clear state and mark as stale
      # since all children artists are part of the state, clearing it
      # will trigger a deletion by the backend at the next draw cycle
      self._clear_state()
      self.stale = True
  
      # get local refs to everything (just for less typing)
      graph = self.graph
      palette = self.kwds["palette"]
      layout = self.kwds["layout"]
      kwds = self.kwds
  
      # Construct the vertex, edge and label drawers
      if not hasattr(self, "_vertex_drawer"):
          self._vertex_drawer = self._vertex_drawer_factory(
              self.axes, palette, layout
          )
      if not hasattr(self, "_edge_drawer"):
          self._edge_drawer = self._edge_drawer_factory(
              self.axes, palette
          )
  
      # Construct the visual vertex/edge builders based on the specifications
      # provided by the vertex_drawer and the edge_drawer
      if not hasattr(self, "_vertex_builder"):
          self._vertex_builder = (
              self._vertex_drawer.VisualVertexBuilder(graph.vs, kwds)
          )
      if not hasattr(self, "_edge_builder"):
          self._edge_builder = self._edge_drawer.VisualEdgeBuilder(
              graph.es, kwds
          )
  
      # Determine the order in which we will draw the vertices and edges
      # These methods come from AbstractGraphDrawer
      self._vertex_order = self._determine_vertex_order(graph, kwds)
      self._edge_order = self._determine_edge_order(graph, kwds)
  
      self._draw_groups()
      self._draw_vertices()
      self._draw_edges()
      self._draw_vertex_labels()
      self._draw_edge_labels()
  
      # Callbacks for other vertex properties, to ensure they are in sync
      # with vertex_builder.
      # NOTE: no need to reprocess here because it does not affect other
      # parts of the container artist (e.g. edges)
      def vertex_stale_callback(artist):
          # If the stale state emerges from other properties, we can salvage
          # the other artists but we have to update the vertex builder anyway
          # in case a _reprocess is triggered by something else.
          prop_pairs = (
              ("edgecolor", "frame_color"),
              ("facecolor", "color"),
              ("linewidth", "frame_width"),
              ("zorder", "zorder"),
              ("sizes", "size"),
          )
          for mpl_prop, ig_prop in prop_pairs:
              values = getattr(artist, "get_" + mpl_prop)()
              try:
                  iter(values)
              except TypeError:
                  values = [values] * len(artist.get_paths())
              for value, visual_vertex in zip(
                  values, self._vertex_builder
              ):
                  setattr(visual_vertex, ig_prop, value)
  
          # If the size is stale, one needs to redraw everything
          if artist._stale_size:
              self._reprocess()
  
      # Edge callback, keeps the edge builder in sync with the actual state
      # of the artist
      def edge_stale_callback(artist):
          prop_pairs = (
              ("edgecolor", "color"),
              ("linewidth", "width"),
              ("zorder", "zorder"),
              ("arrow_size", "arrow_size"),
              ("arrow_width", "arrow_width"),
          )
          for mpl_prop, ig_prop in prop_pairs:
              values = getattr(artist, "get_" + mpl_prop)()
              try:
                  iter(values)
              except TypeError:
                  values = [values] * len(artist.get_paths())
              for value, visual_edge in zip(values, self._edge_builder):
                  setattr(visual_edge, ig_prop, value)
  
              # Sync facecolor from edgecolor
              if mpl_prop == "edgecolor":
                  artist._facecolors = artist._edgecolors
  
      self._vertices.stale_callback_post = vertex_stale_callback
      self._edges.stale_callback_post = edge_stale_callback
  
      # Forward mpl properties to children
      # TODO sort out all of the things that need to be forwarded
      for child in self.get_children():
          # set the figure / axes on child, this ensures each primitive
          # knows where to draw
          if hasattr(child, "set_figure"):
              child.set_figure(self.figure)
          child.axes = self.axes
  
          # forward the clippath/box to the children need this logic
          # because mpl exposes some fast-path logic
          clip_path = self.get_clip_path()
          if clip_path is None:
              clip_box = self.get_clip_box()
              child.set_clip_box(clip_box)
          else:
              child.set_clip_path(clip_path)
  
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 17 for calling the GraphArtist obj's underlying member method code with example usage: obj._reprocess() without return types