Current File : //usr/share/texlive/texmf-dist/tex/generic/pgf/graphdrawing/lua/pgf/gd/control/LayoutPipeline.lua

-- Copyright 2012 by Till Tantau
--
-- This file may be distributed an/or modified
--
-- 1. under the LaTeX Project Public License and/or
-- 2. under the GNU Public License
--
-- See the file doc/generic/pgf/licenses/LICENSE for more information

-- @release $Header$


---
-- This class controls the running of graph drawing algorithms on
-- graphs. In particular, it performs pre- and posttransformations and
-- also invokes the collapsing of sublayouts.
--
-- You do not call any of the methods of this class directly, the
-- whole class is included only for documentation purposes.
--
-- Before an algorithm is applied, a number of transformations will
-- have been applied, depending on the algorithm's |preconditions|
-- field:
-- %
-- \begin{itemize}
--   \item |connected|
--
--     If this property is set for an algorithm (that is, in the
--     |declare| statement for the algorithm the |predconditions| field
--     has the entry |connected=true| set), then the graph will be
--     decomposed into connected components. The algorithm is run on each
--     component individually.
--   \item |tree|
--
--     When set, the field |spanning_tree| of the algorithm will be set
--     to a spanning tree of the graph. This option implies |connected|.
--   \item |loop_free|
--
--     When set, all loops (arcs from a vertex to itself) will have been
--     removed when the algorithm runs.
--
--   \item |at_least_two_nodes|
--
--     When explicitly set to |false| (this precondition is |true| by
--     default), the algorithm will even be run if there is only a
--     single vertex in the graph.
-- \end{itemize}
--
-- Once the algorithm has run, the algorithm's |postconditions| will
-- be processed:
-- %
-- \begin{itemize}
--   \item |upward_oriented|
--
--     When set, the algorithm tells the layout pipeline that the graph
--     has been laid out in a layered manner with each layer going from
--     left to right and layers at a whole going upwards (positive
--     $y$-coordinates). The graph will then be rotated and possibly
--     swapped in accordance with the |grow| key set by the user.
--   \item |fixed|
--
--     When set, no rotational postprocessing will be done after the
--     algorithm has run. Usually, a graph is rotated to meet a user's
--     |orient| settings. However, when the algorithm has already
--     ``ideally'' rotated the graph, set this postcondition.
-- \end{itemize}
--
--
-- In addition to the above-described always-present and automatic
-- transformations, users may also specify additional pre- and
-- posttransformations. This happens when users install additional
-- algorithms in appropriate phases. In detail, the following happens
-- in order:
-- %
-- \begin{enumerate}
--   \item If specified, the graph is decomposed into connected
--     components and the following steps are applied to each component
--     individually.
--   \item All algorithms in the phase stack for the phase
--     |preprocessing| are applied to the component. These algorithms are
--     run one after the other in the order they appear in the phase stack.
--   \item If necessary, the spanning tree is now computed and
--     rotational information is gathered.
--   \item The single algorithm in phase |main| is called.
--   \item All algorithms in the phase stack for the phase 
--     |edge routing| are run.
--   \item All algorithms in the phase stack for phase |postprocessing|
--     are run.
--   \item Edge syncing, orientation, and anchoring are applied.
-- \end{enumerate}
--
-- If sublayouts are used, all of the above (except for anchoring)
-- happens for each sublayout.

local LayoutPipeline = {}


-- Namespace
require("pgf.gd.control").LayoutPipeline = LayoutPipeline


-- Imports
local Direct        = require "pgf.gd.lib.Direct"
local Storage       = require "pgf.gd.lib.Storage"
local Simplifiers   = require "pgf.gd.lib.Simplifiers"
local LookupTable   = require "pgf.gd.lib.LookupTable"
local Transform     = require "pgf.gd.lib.Transform"

local Arc           = require "pgf.gd.model.Arc"
local Vertex        = require "pgf.gd.model.Vertex"
local Digraph       = require "pgf.gd.model.Digraph"
local Coordinate    = require "pgf.gd.model.Coordinate"
local Path          = require "pgf.gd.model.Path"

local Sublayouts    = require "pgf.gd.control.Sublayouts"

local lib           = require "pgf.gd.lib"

local InterfaceCore = require "pgf.gd.interface.InterfaceCore"




-- Forward definitions

local prepare_events



-- The main ``graph drawing pipeline'' that handles the pre- and
-- postprocessing for a graph. This method is called by the display
-- interface.
--
-- @param scope A graph drawing scope.

function LayoutPipeline.run(scope)

  -- The pipeline...

  -- Step 1: Preparations

  -- Prepare events
  prepare_events(scope.events)

  -- Step 2: Recursively layout the graph, starting with the root layout
  local root_layout = assert(scope.collections[InterfaceCore.sublayout_kind][1], "no layout in scope")

  scope.syntactic_digraph =
    Sublayouts.layoutRecursively (scope,
                  root_layout,
                  LayoutPipeline.runOnLayout,
                  { root_layout })

  -- Step 3: Anchor the graph
  LayoutPipeline.anchor(scope.syntactic_digraph, scope)

  -- Step 4: Apply regardless transforms
  Sublayouts.regardless(scope.syntactic_digraph)

  -- Step 5: Cut edges
  LayoutPipeline.cutEdges(scope.syntactic_digraph)

end



--
-- This method is called by the sublayout rendering pipeline when the
-- algorithm should be invoked for an individual graph. At this point,
-- the sublayouts will already have been collapsed.
--
-- @param scope The graph drawing scope.
-- @param algorithm_class The to-be-applied algorithm class.
-- @param layout_graph A subgraph of the syntactic digraph which is
-- restricted to the current layout and in which sublayouts have
-- been contracted to single nodes.
-- @param layout The layout to which the graph belongs.
--
function LayoutPipeline.runOnLayout(scope, algorithm_class, layout_graph, layout)

  if #layout_graph.vertices < 1 then
    return
  end

  -- The involved main graphs:
  local layout_copy = Digraph.new (layout_graph) --Direct.digraphFromSyntacticDigraph(layout_graph)
  for _,a in ipairs(layout_graph.arcs) do
    local new_a = layout_copy:connect(a.tail,a.head)
    new_a.syntactic_edges = a.syntactic_edges
  end

  -- Step 1: Decompose the graph into connected components, if necessary:
  local syntactic_components
  if algorithm_class.preconditions.tree or algorithm_class.preconditions.connected or layout_graph.options.componentwise then
    syntactic_components = LayoutPipeline.decompose(layout_copy)
    LayoutPipeline.sortComponents(layout_graph.options['component order'], syntactic_components)
  else
    -- Only one component: The graph itself...
    syntactic_components = { layout_copy }
  end

  -- Step 2: For all components do:
  for i,syntactic_component in ipairs(syntactic_components) do

    -- Step 2.1: Reset random number generator to make sure that the
    -- same graph is always typeset in  the same way.
    lib.randomseed(layout_graph.options['random seed'])

    local digraph  = Direct.digraphFromSyntacticDigraph(syntactic_component)

    -- Step 2.3: If requested, remove loops
    if algorithm_class.preconditions.loop_free then
      for _,v in ipairs(digraph.vertices) do
        digraph:disconnect(v,v)
      end
    end

    -- Step 2.4: Precompute the underlying undirected graph
    local ugraph  = Direct.ugraphFromDigraph(digraph)

    -- Step 2.4a: Run preprocessor
    for _,class in ipairs(layout_graph.options.algorithm_phases["preprocessing stack"]) do
      class.new{
        digraph = digraph,
        ugraph = ugraph,
        scope = scope,
        layout = layout,
        layout_graph = layout_graph,
        syntactic_component = syntactic_component,
      }:run()
    end

    -- Step 2.5: Create an algorithm object
    local algorithm = algorithm_class.new{
      digraph = digraph,
      ugraph = ugraph,
      scope = scope,
      layout = layout,
      layout_graph = layout_graph,
      syntactic_component = syntactic_component,
    }

    -- Step 2.7: Compute a spanning tree, if necessary
    if algorithm_class.preconditions.tree then
      local spanning_algorithm_class = syntactic_component.options.algorithm_phases["spanning tree computation"]
      algorithm.spanning_tree =
        spanning_algorithm_class.new{
          ugraph = ugraph,
          events = scope.events
        }:run()
    end

    -- Step 2.8: Compute growth-adjusted sizes
    algorithm.rotation_info = LayoutPipeline.prepareRotateAround(algorithm.postconditions, syntactic_component)
    algorithm.adjusted_bb = Storage.newTableStorage()
    LayoutPipeline.prepareBoundingBoxes(algorithm.rotation_info, algorithm.adjusted_bb, syntactic_component, syntactic_component.vertices)

    -- Step 2.9: Finally, run algorithm on this component!
    if #digraph.vertices > 1 or algorithm_class.run_also_for_single_node
                             or algorithm_class.preconditions.at_least_two_nodes == false then
      -- Main run of the algorithm:
      if algorithm_class.old_graph_model then
        LayoutPipeline.runOldGraphModel(scope, digraph, algorithm_class, algorithm)
      else
        algorithm:run ()
      end
    end

    -- Step 2.9a: Run edge routers
    for _,class in ipairs(layout_graph.options.algorithm_phases["edge routing stack"]) do
      class.new{
        digraph = digraph,
        ugraph = ugraph,
        scope = scope,
        layout = layout,
        layout_graph = layout_graph,
        syntactic_component = syntactic_component,
      }:run()
    end

    -- Step 2.9b: Run postprocessor
    for _,class in ipairs(layout_graph.options.algorithm_phases["postprocessing stack"]) do
      class.new{
        digraph = digraph,
        ugraph = ugraph,
        scope = scope,
        layout = layout,
        layout_graph = layout_graph,
        syntactic_component = syntactic_component,
      }:run()
    end

    -- Step 2.10: Sync the graphs
    digraph:sync()
    ugraph:sync()
    if algorithm.spanning_tree then
      algorithm.spanning_tree:sync()
    end

    -- Step 2.11: Orient the graph
    LayoutPipeline.orient(algorithm.rotation_info, algorithm.postconditions, syntactic_component, scope)
  end

  -- Step 3: Packing:
  LayoutPipeline.packComponents(layout_graph, syntactic_components)

end






---
-- This function is called internally to perform the graph anchoring
-- procedure described in
-- Section~\ref{subsection-library-graphdrawing-anchoring}. These
-- transformations are always performed.
--
-- @param graph A graph
-- @param scope The scope

function LayoutPipeline.anchor(graph, scope)

  -- Step 1: Find anchor node:
  local anchor_node

  local anchor_node_name = graph.options['anchor node']
  if anchor_node_name then
    anchor_node = scope.node_names[anchor_node_name]
  end

  if not graph:contains(anchor_node) then
    anchor_node =
      lib.find (graph.vertices, function (v) return v.options['anchor here'] end) or
      lib.find (graph.vertices, function (v) return v.options['desired at'] end) or
      graph.vertices[1]
  end

  -- Sanity check
  assert(graph:contains(anchor_node), "anchor node is not in graph!")

  local desired = anchor_node.options['desired at'] or graph.options['anchor at']
  local delta = desired - anchor_node.pos

  -- Step 3: Shift nodes
  for _,v in ipairs(graph.vertices) do
    v.pos:shiftByCoordinate(delta)
  end
  for _,a in ipairs(graph.arcs) do
    if a.path then a.path:shiftByCoordinate(delta) end
    for _,e in ipairs(a.syntactic_edges) do
      e.path:shiftByCoordinate(delta)
    end
  end
end



---
-- This method tries to determine in which direction the graph is supposed to
-- grow and in which direction the algorithm will grow the graph. These two
-- pieces of information together produce a necessary rotation around some node.
-- This rotation is returned in a table.
--
-- Note that this method does not actually cause a rotation to happen; this is
-- left to other method.
--
-- @param postconditions The algorithm's postconditions.
-- @param graph An undirected graph
-- @return A table containing the computed information.

function LayoutPipeline.prepareRotateAround(postconditions, graph)

  -- Find the vertex from which we orient
  local swap = true

  local v,_,grow = lib.find (graph.vertices, function (v) return v.options["grow"] end)

  if not v and graph.options["grow"] then
    v,grow,swap = graph.vertices[1], graph.options["grow"], true
  end

  if not v then
    v,_,grow =  lib.find (graph.vertices, function (v) return v.options["grow'"] end)
    swap = false
  end

  if not v and graph.options["grow'"] then
    v,grow,swap = graph.vertices[1], graph.options["grow'"], false
  end

  if not v then
    v, grow, swap = graph.vertices[1], -90, true
  end

  -- Now compute the rotation
  local info = {}
  local growth_direction = (postconditions.upward_oriented and 90) or (postconditions.upward_oriented_swapped and 90)

  if postconditions.upward_oriented_swapped then
    swap = not swap
  end

  if growth_direction == "fixed" then
    info.angle = 0 -- no rotation
  elseif growth_direction then
    info.from_node = v
    info.from_angle = growth_direction/360*2*math.pi
    info.to_angle = grow/360*2*math.pi
    info.swap = swap
    info.angle = info.to_angle - info.from_angle
  else
    info.from_node = v
    local other = lib.find_min(
      graph:outgoing(v),
      function (a)
        if a.head ~= v and a:eventIndex() then
          return a, a:eventIndex()
        end
      end)
    info.to_node = (other and other.head) or
      (graph.vertices[1] == v and graph.vertices[2] or graph.vertices[1])
    info.to_angle = grow/360*2*math.pi
    info.swap = swap
    info.angle = info.to_angle - math.atan2(info.to_node.pos.y - v.pos.y, info.to_node.pos.x - v.pos.x)
  end

  return info
end



---
-- Compute growth-adjusted node sizes.
--
-- For each node of the graph, compute bounding box of the node that
-- results when the node is rotated so that it is in the correct
-- orientation for what the algorithm assumes.
--
-- The ``bounding box'' actually consists of the fields
-- %
-- \begin{itemize}
--   \item |sibling_pre|,
--   \item |sibling_post|,
--   \item |layer_pre|, and
--   \item |layer_post|,
-- \end{itemize}
-- %
-- which correspond to ``min x'', ``min y'', ``min y'', and ``max y''
-- for a tree growing up.
--
-- The computation of the ``bounding box'' treats a centered circle in
-- a special way, all other shapes are currently treated like a
-- rectangle.
--
-- @param rotation_info The table computed by the function prepareRotateAround
-- @param packing_storage A storage in which the computed distances are stored.
-- @param graph     An graph
-- @param vertices  An array of to-be-prepared vertices inside graph

function LayoutPipeline.prepareBoundingBoxes(rotation_info, adjusted_bb, graph, vertices)

  local angle = assert(rotation_info.angle, "angle field missing")
  local swap  = rotation_info.swap

  for _,v in ipairs(vertices) do
    local bb = adjusted_bb[v]
    local a  = angle

    if v.shape == "circle" then
      a = 0 -- no rotation for circles.
    end

    -- Fill the bounding box field,
    bb.sibling_pre = math.huge
    bb.sibling_post = -math.huge
    bb.layer_pre = math.huge
    bb.layer_post = -math.huge

    local c = math.cos(angle)
    local s = math.sin(angle)
    for _,p in ipairs(v.path:coordinates()) do
      local x =  p.x*c + p.y*s
      local y = -p.x*s + p.y*c

      bb.sibling_pre = math.min (bb.sibling_pre, x)
      bb.sibling_post = math.max (bb.sibling_post, x)
      bb.layer_pre = math.min (bb.layer_pre, y)
      bb.layer_post = math.max (bb.layer_post, y)
    end

    -- Flip sibling per and post if flag:
    if swap then
      bb.sibling_pre, bb.sibling_post = -bb.sibling_post, -bb.sibling_pre
    end
  end
end





--
-- Rotate the whole graph around a point
--
-- Causes the graph to be rotated around \meta{around} so that what
-- used to be the |from_angle| becomes the |to_angle|. If the flag |swap|
-- is set, the graph is additionally swapped along the |to_angle|.
--
-- @param graph The to-be-rotated (undirected) graph
-- @param around_x The $x$-coordinate of the point around which the graph should be rotated
-- @param around_y The $y$-coordinate
-- @param from An ``old'' angle
-- @param to A ``new'' angle
-- @param swap A boolean that, when true, requests that the graph is
--             swapped (flipped) along the new angle

function LayoutPipeline.rotateGraphAround(graph, around_x, around_y, from, to, swap)

  -- Translate to origin
  local t = Transform.new_shift(-around_x, -around_y)

  -- Rotate to zero degrees:
  t = Transform.concat(Transform.new_rotation(-from), t)

  -- Swap
  if swap then
    t = Transform.concat(Transform.new_scaling(1,-1), t)
  end

  -- Rotate to from degrees:
  t = Transform.concat(Transform.new_rotation(to), t)

  -- Translate back
  t = Transform.concat(Transform.new_shift(around_x, around_y), t)

  for _,v in ipairs(graph.vertices) do
    v.pos:apply(t)
  end
  for _,a in ipairs(graph.arcs) do
    for _,p in ipairs(a:pointCloud()) do
      p:apply(t)
    end
  end
end



--
-- Orient the whole graph using two nodes
--
-- The whole graph is rotated so that the line from the first node to
-- the second node has the given angle. If swap is set to true, the
-- graph is also flipped along this line.
--
-- @param graph
-- @param first_node
-- @param seond_node
-- @param target_angle
-- @param swap

function LayoutPipeline.orientTwoNodes(graph, first_node, second_node, target_angle, swap)
  if first_node and second_node then
    -- Compute angle between first_node and second_node:
    local x = second_node.pos.x - first_node.pos.x
    local y = second_node.pos.y - first_node.pos.y

    local angle = math.atan2(y,x)
    LayoutPipeline.rotateGraphAround(graph, first_node.pos.x,
               first_node.pos.y, angle, target_angle, swap)
  end
end



---
-- Performs a post-layout orientation of the graph by performing the
-- steps documented in Section~\ref{subsection-library-graphdrawing-standard-orientation}.
--
-- @param rotation_info The info record computed by the function |prepareRotateAround|.
-- @param postconditions The algorithm's postconditions.
-- @param graph A to-be-oriented graph.
-- @param scope The graph drawing scope.

function LayoutPipeline.orient(rotation_info, postconditions, graph, scope)

  -- Sanity check
  if #graph.vertices < 2 then return end

  -- Step 1: Search for global graph orient options:
  local function f (orient, tail, head, flag)
    if orient and head and tail then
      local n1 = scope.node_names[tail]
      local n2 = scope.node_names[head]
      if graph:contains(n1) and graph:contains(n2) then
        LayoutPipeline.orientTwoNodes(graph, n1, n2, orient/360*2*math.pi, flag)
        return true
      end
    end
  end
  if f(graph.options["orient"], graph.options["orient tail"],graph.options["orient head"], false) then return end
  if f(graph.options["orient'"], graph.options["orient tail"],graph.options["orient head"], true) then return end
  local tail, head = string.match(graph.options["horizontal"] or "", "^(.*) to (.*)$")
  if f(0, tail, head, false) then return end
  local tail, head = string.match(graph.options["horizontal'"] or "", "^(.*) to (.*)$")
  if f(0, tail, head, true) then return end
  local tail, head = string.match(graph.options["vertical"] or "", "^(.*) to (.*)$")
  if f(-90, tail, head, false) then return end
  local tail, head = string.match(graph.options["vertical'"] or "", "^(.*) to (.*)$")
  if f(-90, tail, head, true) then return end

  -- Step 2: Search for a node with the orient option:
  for _, v in ipairs(graph.vertices) do
    local function f (key, flag)
      local orient = v.options[key]
      local head   = v.options["orient head"]
      local tail   = v.options["orient tail"]

      if orient and head then
        local n2 = scope.node_names[head]
        if graph:contains(n2) then
          LayoutPipeline.orientTwoNodes(graph, v, n2, orient/360*2*math.pi, flag)
          return true
        end
          elseif orient and tail then
        local n1 = scope.node_names[tail]
        if graph:contains(n1) then
          LayoutPipeline.orientTwoNodes(graph, n1, v, orient/360*2*math.pi, flag)
          return true
        end
      end
    end
    if f("orient", false) then return end
    if f("orient'", true) then return end
  end

  -- Step 3: Search for an edge with the orient option:
  for _, a in ipairs(graph.arcs) do
    if a:options("orient",true) then
      return LayoutPipeline.orientTwoNodes(graph, a.tail, a.head, a:options("orient")/360*2*math.pi, false)
    end
    if a:options("orient'",true) then
      return LayoutPipeline.orientTwoNodes(graph, a.tail, a.head, a:options("orient'")/360*2*math.pi, true)
    end
  end

  -- Step 4: Search two nodes with a desired at option:
  local first, second, third

  for _, v in ipairs(graph.vertices) do
    if v.options['desired at'] then
      if first then
        if second then
          third = v
          break
        else
          second = v
        end
          else
        first = v
      end
    end
  end

  if second then
    local a = first.options['desired at']
    local b = second.options['desired at']
    return LayoutPipeline.orientTwoNodes(graph, first, second, math.atan2(b.y-a.y,b.x-a.x), false)
  end

  -- Computed during preprocessing:
  if rotation_info.from_node and postconditions.fixed ~= true then
    local x = rotation_info.from_node.pos.x
    local y = rotation_info.from_node.pos.y
    local from_angle = rotation_info.from_angle or math.atan2(rotation_info.to_node.pos.y - y, rotation_info.to_node.pos.x - x)

    LayoutPipeline.rotateGraphAround(graph, x, y, from_angle, rotation_info.to_angle, rotation_info.swap)
  end
end




---
-- This internal function is called to decompose a graph into its
-- components. Whether or not this function is called depends on
-- whether the precondition |connected| is set for the algorithm class
-- and whether the |componentwise| key is used.
--
-- @param graph A to-be-decomposed graph
--
-- @return An array of graph objects that represent the connected components of the graph.

function LayoutPipeline.decompose (digraph)

  -- The list of connected components (node sets)
  local components = {}

  -- Remember, which graphs have already been visited
  local visited = {}

  for _,v in ipairs(digraph.vertices) do
    if not visited[v] then
      -- Start a depth-first-search of the graph, starting at node n:
      local stack = { v }
      local component = Digraph.new {
        syntactic_digraph = digraph.syntactic_digraph,
        options = digraph.options
      }

      while #stack >= 1 do
        local tos = stack[#stack]
        stack[#stack] = nil -- pop

        if not visited[tos] then

          -- Visit pos:
          component:add { tos }
          visited[tos] = true

          -- Push all unvisited neighbors:
          for _,a in ipairs(digraph:incoming(tos)) do
            local neighbor = a.tail
            if not visited[neighbor] then
              stack[#stack+1] = neighbor -- push
            end
          end
          for _,a in ipairs(digraph:outgoing(tos)) do
            local neighbor = a.head
            if not visited[neighbor] then
              stack[#stack+1] = neighbor -- push
            end
          end
        end
      end

      -- Ok, vertices will now contain all vertices reachable from n.
      components[#components+1] = component
    end
  end

  if #components < 2 then
    return { digraph }
  end

  for _,c in ipairs(components) do
    table.sort (c.vertices, function (u,v) return u.event.index < v.event.index end)
    for _,v in ipairs(c.vertices) do
      for _,a in ipairs(digraph:outgoing(v)) do
        local new_a = c:connect(a.tail, a.head)
        new_a.syntactic_edges = a.syntactic_edges
      end
      for _,a in ipairs(digraph:incoming(v)) do
        local new_a = c:connect(a.tail, a.head)
        new_a.syntactic_edges = a.syntactic_edges
      end
    end
  end

  return components
end




-- Handling of component order
--
-- LayoutPipeline are ordered according to a function that is stored in
-- a key of the |LayoutPipeline.component_ordering_functions| table
-- whose name is the graph option |component order|.
--
-- @param component_order An ordering method
-- @param subgraphs A list of to-be-sorted subgraphs

function LayoutPipeline.sortComponents(component_order, subgraphs)
  if component_order then
    local f = LayoutPipeline.component_ordering_functions[component_order]
    if f then
      table.sort (subgraphs, f)
    end
  end
end


-- Right now, we hardcode the functions here. Perhaps make this
-- dynamic in the future. Could easily be done on the tikzlayer,
-- actually.

LayoutPipeline.component_ordering_functions = {
  ["increasing node number"] =
    function (g,h)
      if #g.vertices == #h.vertices then
        return g.vertices[1].event.index < h.vertices[1].event.index
      else
        return #g.vertices < #h.vertices
      end
    end,
  ["decreasing node number"] =
    function (g,h)
      if #g.vertices == #h.vertices then
        return g.vertices[1].event.index < h.vertices[1].event.index
      else
        return #g.vertices > #h.vertices
      end
    end,
  ["by first specified node"] = nil,
}




local function compute_rotated_bb(vertices, angle, sep, bb)

  local r = Transform.new_rotation(-angle)

  for _,v in ipairs(vertices) do
    -- Find the rotated bounding box field,
    local t = Transform.concat(r,Transform.new_shift(v.pos.x, v.pos.y))

    local min_x = math.huge
    local max_x = -math.huge
    local min_y = math.huge
    local max_y = -math.huge

    for _,e in ipairs(v.path) do
      if type(e) == "table" then
        local c = e:clone()
        c:apply(t)

        min_x = math.min (min_x, c.x)
        max_x = math.max (max_x, c.x)
        min_y = math.min (min_y, c.y)
        max_y = math.max (max_y, c.y)
      end
    end

    -- Enlarge by sep:
    min_x = min_x - sep
    max_x = max_x + sep
    min_y = min_y - sep
    max_y = max_y + sep

    local _,_,_,_,c_x,c_y = v:boundingBox()
    local center = Coordinate.new(c_x,c_y)

    center:apply(t)

    bb[v].min_x = min_x
    bb[v].max_x = max_x
    bb[v].min_y = min_y
    bb[v].max_y = max_y
    bb[v].c_y = center.y
  end
end



---
-- This internal function packs the components of a graph. See
-- Section~\ref{subsection-gd-component-packing} for details.
--
-- @param graph The graph
-- @param components A list of components

function LayoutPipeline.packComponents(syntactic_digraph, components)

  local vertices = Storage.newTableStorage()
  local bb = Storage.newTableStorage()

  -- Step 1: Preparation, rotation to target direction
  local sep = syntactic_digraph.options['component sep']
  local angle = syntactic_digraph.options['component direction']/180*math.pi

  local mark = {}
  for _,c in ipairs(components) do

    -- Setup the lists of to-be-considered nodes
    local vs = {}
    for _,v in ipairs(c.vertices) do
      vs [#vs + 1] = v
    end

    for _,a in ipairs(c.arcs) do
      for _,p in ipairs(a:pointCloud()) do
        vs [#vs + 1] = Vertex.new { pos = p }
      end
    end
    vertices[c] = vs

    compute_rotated_bb(vs, angle, sep/2, bb)
  end

  local x_shifts = { 0 }
  local y_shifts = {}

  -- Step 2: Vertical alignment
  for i,c in ipairs(components) do
    local max_max_y = -math.huge
    local max_center_y = -math.huge
    local min_min_y = math.huge
    local min_center_y = math.huge

    for _,v in ipairs(c.vertices) do
      local info = bb[v]
      max_max_y = math.max(info.max_y, max_max_y)
      max_center_y = math.max(info.c_y, max_center_y)
      min_min_y = math.min(info.min_y, min_min_y)
      min_center_y = math.min(info.c_y, min_center_y)
    end

    -- Compute alignment line
    local valign = syntactic_digraph.options['component align']
    local line
    if valign == "counterclockwise bounding box" then
      line = max_max_y
    elseif valign == "counterclockwise" then
      line = max_center_y
    elseif valign == "center" then
      line = (max_max_y + min_min_y) / 2
    elseif valign == "clockwise" then
      line = min_center_y
    elseif valign == "first node" then
      line = bb[c.vertices[1]].c_y
    else
      line = min_min_y
    end

    -- Overruled?
    for _,v in ipairs(c.vertices) do
      if v.options['align here'] then
        line = bb[v].c_y
        break
      end
    end

    -- Ok, go!
    y_shifts[i] = -line

    -- Adjust nodes:
    for _,v in ipairs(vertices[c]) do
      local info = bb[v]
      info.min_y = info.min_y - line
      info.max_y = info.max_y - line
      info.c_y = info.c_y - line
    end
  end

  -- Step 3: Horizontal alignment
  local y_values = {}

  for _,c in ipairs(components) do
    for _,v in ipairs(vertices[c]) do
      local info = bb[v]
      y_values[#y_values+1] = info.min_y
      y_values[#y_values+1] = info.max_y
      y_values[#y_values+1] = info.c_y
    end
  end

  table.sort(y_values)

  local y_ranks = {}
  local right_face = {}
  for i=1,#y_values do
    y_ranks[y_values[i]] = i
    right_face[i] = -math.huge
  end



  for i=1,#components-1 do
    -- First, update right_face:
    local touched = {}

    for _,v in ipairs(vertices[components[i]]) do
      local info = bb[v]
      local border = info.max_x

      for i=y_ranks[info.min_y],y_ranks[info.max_y] do
        touched[i] = true
        right_face[i] = math.max(right_face[i], border)
      end
    end

    -- Fill up the untouched entries:
    local right_max = -math.huge
    for i=1,#y_values do
      if not touched[i] then
        -- Search for next and previous touched
        local interpolate = -math.huge
        for j=i+1,#y_values do
          if touched[j] then
            interpolate = math.max(interpolate,right_face[j] - (y_values[j] - y_values[i]))
            break
          end
        end
        for j=i-1,1,-1 do
          if touched[j] then
            interpolate = math.max(interpolate,right_face[j] - (y_values[i] - y_values[j]))
            break
          end
        end
        right_face[i] = math.max(interpolate,right_face[i])
      end
      right_max = math.max(right_max, right_face[i])
    end

    -- Second, compute the left face
    local touched = {}
    local left_face = {}
    for i=1,#y_values do
      left_face[i] = math.huge
    end
    for _,v in ipairs(vertices[components[i+1]]) do
      local info = bb[v]
      local border = info.min_x

      for i=y_ranks[info.min_y],y_ranks[info.max_y] do
        touched[i] = true
        left_face[i] = math.min(left_face[i], border)
      end
    end

    -- Fill up the untouched entries:
    local left_min = math.huge
    for i=1,#y_values do
      if not touched[i] then
        -- Search for next and previous touched
        local interpolate = math.huge
        for j=i+1,#y_values do
          if touched[j] then
            interpolate = math.min(interpolate,left_face[j] + (y_values[j] - y_values[i]))
            break
          end
        end
        for j=i-1,1,-1 do
          if touched[j] then
            interpolate = math.min(interpolate,left_face[j] + (y_values[i] - y_values[j]))
            break
          end
        end
        left_face[i] = interpolate
      end
      left_min = math.min(left_min, left_face[i])
    end

    -- Now, compute the shift.
    local shift = -math.huge

    if syntactic_digraph.options['component packing'] == "rectangular" then
      shift = right_max - left_min
    else
      for i=1,#y_values do
        shift = math.max(shift, right_face[i] - left_face[i])
      end
    end

    -- Adjust nodes:
    x_shifts[i+1] = shift
    for _,v in ipairs(vertices[components[i+1]]) do
      local info = bb[v]
      info.min_x = info.min_x + shift
      info.max_x = info.max_x + shift
    end
  end

  -- Now, rotate shifts
  for i,c in ipairs(components) do
    local x =  x_shifts[i]*math.cos(angle) - y_shifts[i]*math.sin(angle)
    local y =  x_shifts[i]*math.sin(angle) + y_shifts[i]*math.cos(angle)

    for _,v in ipairs(vertices[c]) do
      v.pos.x = v.pos.x + x
      v.pos.y = v.pos.y + y
    end
  end
end







--
-- Store for each begin/end event the index of
-- its corresponding end/begin event
--
-- @param events An event list

prepare_events =
  function (events)
    local stack = {}

    for i=1,#events do
      if events[i].kind == "begin" then
        stack[#stack + 1] = i
      elseif events[i].kind == "end" then
        local tos = stack[#stack]
        stack[#stack] = nil -- pop

        events[tos].end_index = i
        events[i].begin_index = tos
      end
    end
  end



---
-- Cut the edges. This function handles the ``cutting'' of edges. The
-- idea is that every edge is a path going from the center of the from
-- node to the center of the target node. Now, we intersect this path
-- with the path of the start node and cut away everything before this
-- intersection. Likewise, we intersect the path with the head node
-- and, again, cut away everything following the intersection.
--
-- These cuttings are not done if appropriate options are set.

function LayoutPipeline.cutEdges(graph)

  for _,a in ipairs(graph.arcs) do
    for _,e in ipairs(a.syntactic_edges) do
      local p = e.path
      p:makeRigid()
      local orig = p:clone()

      if e.options['tail cut'] and e.tail.options['cut policy'] == "as edge requests"
        or e.tail.options['cut policy'] == "all" then

        local vpath = e.tail.path:clone()
        vpath:shiftByCoordinate(e.tail.pos)

        local x = p:intersectionsWith (vpath)

        if #x > 0 then
          p:cutAtBeginning(x[1].index, x[1].time)
        end
      end

      if e.options['head cut'] and e.head.options['cut policy'] == "as edge requests"
        or e.head.options['cut policy'] == "all" then

        local vpath = e.head.path:clone()
        vpath:shiftByCoordinate(e.head.pos)
        x = p:intersectionsWith (vpath)
        if #x > 0 then
          p:cutAtEnd(x[#x].index, x[#x].time)
        else
          -- Check whether there was an intersection with the original
          --path:
          local x2 = orig:intersectionsWith (vpath)
          if #x2 > 0 then
            -- Ok, after cutting the tail vertex, there is no longer
            -- an intersection with the head vertex, but there used to
            -- be one. This means that the vertices overlap and the
            -- path should be ``inside'' them. Hmm...
            if e.options['allow inside edges'] and #p > 1 then
              local from = p[2]
              local to = x2[1].point
              p:clear()
              p:appendMoveto(from)
              p:appendLineto(to)
            else
              p:clear()
            end
          end
        end
      end
    end
  end
end






-- Deprecated stuff

local Node = require "pgf.gd.deprecated.Node"
local Graph = require "pgf.gd.deprecated.Graph"
local Edge = require "pgf.gd.deprecated.Edge"
local Cluster = require "pgf.gd.deprecated.Cluster"





local unique_count = 0

local function compatibility_digraph_to_graph(scope, g)
  local graph = Graph.new()

  -- Graph options
  graph.options = g.options
  graph.orig_digraph = g

  -- Events
  for i,e in ipairs(scope.events) do
    graph.events[i] = e
  end

  -- Nodes
  for _,v in ipairs(g.vertices) do
    if not v.name then
      -- compat needs unique name
      v.name = "auto generated node nameINTERNAL" .. unique_count
      unique_count = unique_count + 1
    end
    local minX, minY, maxX, maxY = v:boundingBox()
    local node = Node.new{
      name = v.name,
      tex = {
        tex_node = v.tex and v.tex.stored_tex_box_number,
        shape = v.shape,
        minX = minX,
        maxX = maxX,
        minY = minY,
        maxY = maxY,
      },
      options = v.options,
      event_index = v.event.index,
      index = v.event.index,
      orig_vertex = v,
    }
    graph:addNode(node)
    graph.events[v.event.index or (#graph.events+1)] = { kind = 'node', parameters = node }
  end

  -- Edges
  local mark = Storage.new()
  for _,a in ipairs(g.arcs) do
    local da = g.syntactic_digraph:arc(a.tail, a.head)
    if da then
      for _,m in ipairs(da.syntactic_edges) do
        if not mark[m] then
          mark[m] = true
          local from_node = graph:findNode(da.tail.name)
          local to_node = graph:findNode(da.head.name)
          local edge = graph:createEdge(from_node, to_node, m.direction, nil, m.options, nil)
          edge.event_index = m.event.index
          edge.orig_m = m
          graph.events[m.event.index] = { kind = 'edge', parameters = edge }
        end
      end
    end
    local da = g.syntactic_digraph:arc(a.head, a.tail)
    if da then
      for _,m in ipairs(da.syntactic_edges) do
        if not mark[m] then
          mark[m] = true
          local from_node = graph:findNode(da.tail.name)
          local to_node = graph:findNode(da.head.name)
          local edge = graph:createEdge(from_node, to_node, m.direction, nil, m.options, nil)
          edge.event_index = m.event.index
          edge.orig_m = m
          graph.events[m.event.index] = { kind = 'edge', parameters = edge }
        end
      end
    end
  end

  table.sort(graph.edges, function(e1,e2) return e1.event_index < e2.event_index end)
  for _,n in ipairs (graph.nodes) do
    table.sort(n.edges, function(e1,e2) return e1.event_index < e2.event_index end)
  end


  -- Clusters
  for _, c in ipairs(scope.collections['same layer'] or {}) do
    cluster = Cluster.new("cluster" .. unique_count)
    unique_count = unique_count+1
    graph:addCluster(cluster)
    for _,v in ipairs(c.vertices) do
      if g:contains(v) then
        cluster:addNode(graph:findNode(v.name))
      end
    end
  end

  return graph
end


local function compatibility_graph_to_digraph(graph)
  for _,n in ipairs(graph.nodes) do
    n.orig_vertex.pos.x = n.pos.x
    n.orig_vertex.pos.y = n.pos.y
  end
  for _,e in ipairs(graph.edges) do
    if #e.bend_points > 0 then
      local c = {}
      for _,x in ipairs(e.bend_points) do
        c[#c+1] = Coordinate.new (x.x, x.y)
      end
      e.orig_m:setPolylinePath(c)
    end
  end
end





function LayoutPipeline.runOldGraphModel(scope, digraph, algorithm_class, algorithm)

  local graph = compatibility_digraph_to_graph(scope, digraph)

  algorithm.graph = graph
  graph:registerAlgorithm(algorithm)

  -- If requested, remove loops
  if algorithm_class.preconditions.loop_free then
    Simplifiers:removeLoopsOldModel(algorithm)
  end

  -- If requested, collapse multiedges
  if algorithm_class.preconditions.simple then
    Simplifiers:collapseMultiedgesOldModel(algorithm)
  end

  if #graph.nodes > 1 then
    -- Main run of the algorithm:
    algorithm:run ()
  end

  -- If requested, expand multiedges
  if algorithm_class.preconditions.simple then
    Simplifiers:expandMultiedgesOldModel(algorithm)
  end

  -- If requested, restore loops
  if algorithm_class.preconditions.loop_free then
    Simplifiers:restoreLoopsOldModel(algorithm)
  end

  compatibility_graph_to_digraph(graph)
end




-- Done

return LayoutPipeline