class_docstr: The classic Sugiyama layout aka layered layout.
  
  - See https://en.wikipedia.org/wiki/Layered_graph_drawing
  - Excellent explanation: https://www.youtube.com/watch?v=Z0RGCWxvCxA
  
  
  **Attributes**
      - dirvh (int): the current aligment state for alignment policy:
               dirvh=0 -> dirh=+1, dirv=-1: leftmost upper
               dirvh=1 -> dirh=-1, dirv=-1: rightmost upper
               dirvh=2 -> dirh=+1, dirv=+1: leftmost lower
               dirvh=3 -> dirh=-1, dirv=+1: rightmost lower
      - order_iter (int): the default number of layer placement iterations
      - order_attr (str): set attribute name used for layer ordering
      - xspace (int): horizontal space between vertices in a layer
      - yspace (int): vertical space between layers
      - dw (int): default width of a vertex
      - dh (int): default height of a vertex
      - g (GraphBase): the graph component reference
      - layers (list[sugiyama.layer.Layer]): the list of layers
      - layoutVertices (dict): associate vertex (possibly dummy) with their sugiyama attributes
      - ctrls (dict): associate edge with all its vertices (including dummies)
      - dag (bool): the current acyclic state
      - init_done (bool): True if things were initialized
  
  **Example**
  
      ::
  
          g = nx.generators.connected_watts_strogatz_graph(1000, 2, 0.3)
          # render
          SugiyamaLayout.draw(g)
          # positions
          positions_dictionary = SugiyamaLayout.arrange(g)
docstr: Initializes the layout algorithm.
   
   Parameters:
      - root (Vertex): a vertex to be used as root
docstr_tok: ["Initializes","the","layout","algorithm",".","Parameters",":","-","root","(","Vertex",")",":","a","vertex","to","be","used","as","root"]
code: def initialize(self, root=None):
      """
      Initializes the layout algorithm.
  
       Parameters:
          - root (Vertex): a vertex to be used as root
      """
      if self.init_done:
          return
  
      # guessed roots are vertices without parents
      no_parent_vertices = [
          v for v in self.g.verticesPoset if len(v.e_in()) == 0
      ]
      if root is None:
          roots = no_parent_vertices
      else:
          found = SugiyamaLayout.ensure_root_is_vertex(self.g, root)
          if found is not None:
              roots = [found]
          else:
              roots = no_parent_vertices
  
      # make the graph acyclic through the FAS algorithm
      _ = self.g.get_scs_with_feedback(roots)
      inverted_edges = [x for x in self.g.edgesPoset if x.feedback]
      self.inverted_edges = inverted_edges
  
      self._layer_all(roots)
  
      # add dummy vertex/edge for 'long' edges:
      for e in self.g.edges():
          self.create_dummies(e)
  
      # precompute some layers values:
      for layer in self.layers:
          layer.setup(self)
  
      # do this only once
      self.init_done = True
  
imports: import pandas, typing
  from sys import getrecursionlimit, setrecursionlimit
  from graphistry.layout.graph import Vertex, GraphBase, Graph, Edge
  from graphistry.layout.utils import DummyVertex, LayoutVertex, Rectangle, size_median
  from graphistry.layout.utils.layer import Layer
label_desc: Use image node_id 8 for calling the SugiyamaLayout obj's underlying member method code with example usage: obj.initialize(root) without return types