private BuchheimNode init_lmost_sibling() { if (!this._lmost_sibling && this.parent && this != this.parent.children[0]) { this._lmost_sibling = this.parent.children[0]; } return(this._lmost_sibling); }
static void third_walk(BuchheimNode tree, float n) { tree.x += n; foreach (var c in tree.children) { third_walk(c, n); } }
static void move_subtree(BuchheimNode wl, BuchheimNode wr, float shift) { var subtrees = wr.number - wl.number; wr.change -= shift / subtrees; wr.shift += shift; wl.change += shift / subtrees; wr.x += shift; wr.mod += shift; }
static BuchheimNode get_ancestor(BuchheimNode vil, BuchheimNode v, BuchheimNode default_ancestor) { if (v.parent.children.Contains(vil.ancestor)) { return(vil.ancestor); } else { return(default_ancestor); } }
static void execute_shifts(BuchheimNode v) { float shift = 0, change = 0; foreach (var w in v.children.Reverse()) { w.x += shift; w.mod += shift; change += w.change; shift += w.shift + change; } }
static BuchheimNode apportion(BuchheimNode v, BuchheimNode default_ancestor, float distance) { var w = v.lbrother(); if (w != null) { var vir = v; var vor = v; var vil = w; var vol = v.lmost_sibling; var sir = v.mod; var sor = v.mod; var sil = vil.mod; var sol = vol.mod; while (vil.right() && vir.left()) { vil = vil.right(); vir = vir.left(); vol = vol.left(); vor = vor.right(); vor.ancestor = v; var shift = (vil.x + sil) - (vir.x + sir) + distance; if (shift > 0) { move_subtree(get_ancestor(vil, v, default_ancestor), v, shift); sir = sir + shift; sor = sor + shift; } sil += vil.mod; sir += vir.mod; sol += vol.mod; sor += vor.mod; } if (vil.right() && !vor.right()) { vor.thread = vil.right(); vor.mod += sil - sor; } else { if (vir.left() && !vol.left()) { vol.thread = vir.left(); vol.mod += sir - sol; } default_ancestor = v; } } return(default_ancestor); }
public BuchheimNode(BuchNodeWrapper node, BuchheimNode parent = null, int depth = 0, int number = 1) { this.x = -1; this.y = depth; this.node = node; this.children = node .Select((c, i) => new BuchheimNode(c, this, depth + 1, i + 1)) .ToArray(); this.parent = parent; this.thread = null; this.mod = 0; this.ancestor = this; this.change = 0; this.shift = 0; this._lmost_sibling = null; this.number = number; }
static float?second_walk(BuchheimNode v, float m = 0, int depth = 0, float?min = null) { v.x += m; v.y = depth; if (min == null || v.x < min) { min = v.x; } foreach (var w in v.children) { min = second_walk(w, m + v.mod, depth + 1, min); } return(min); }
public BuchheimNode lbrother() { BuchheimNode n = null; if (this.parent) { foreach (var node in this.parent.children) { if (node == this) { return(n); } else { n = node; } } } return(n); }
static BuchheimNode firstwalk(BuchheimNode v, float distance = 1) { if (v.children.Length == 0) { if (v.lmost_sibling) { v.x = v.lbrother().x + distance; } else { v.x = 0; } } else { var default_ancestor = v.children[0]; foreach (var c in v.children) { firstwalk(c); default_ancestor = apportion(c, default_ancestor, distance); } execute_shifts(v); var midpoint = (v.children.First().x + v.children.Last().x) / 2f; var ell = v.children.First(); var arr = v.children.Last(); var w = v.lbrother(); if (w) { v.x = w.x + distance; v.mod = v.x - midpoint; } else { v.x = midpoint; } } return(v); }