@@ -764,29 +764,25 @@ getXcoord2 <- function(x, root, parent, child, len, start=0, rev=FALSE) {

         direction <- -1

     }

-    if (any(len < 0) && (is.null(getOption("ignore.negative.edge")) || !getOption("ignore.negative.edge"))){

+    ignore_negative_edge <- getOption("ignore.negative.edge", default=FALSE)

+

+    if (any(len < 0) && !ignore_negative_edge) {

         warning_wrap("The tree contained negative ", 

-                  ifelse(sum(len < 0)>1, "edge lengths", "edge length"),

-                  ". If you want to ignore the ", 

-                  ifelse(sum(len<0) > 1, "edges", "edge"),

-                  ", you can set 'options(ignore.negative.edge=TRUE)', then re-run ggtree."

-        )

+                     ifelse(sum(len < 0)>1, "edge lengths", "edge length"),

+                     ". If you want to ignore the ", 

+                     ifelse(sum(len<0) > 1, "edges", "edge"),

+                     ", you can set 'options(ignore.negative.edge=TRUE)', then re-run ggtree."

+                     )

     }

-

-    if (getOption("ignore.negative.edge", default=FALSE)){

-        while(anyNA(x)) {

-            idx <- which(parent %in% currentNode)

-            newNode <- child[idx]

+    while(anyNA(x)) {

+        idx <- which(parent %in% currentNode)

+        newNode <- child[idx]

+        if (ignore_negative_edge){

             x[newNode] <- x[parent[idx]]+len[idx] * direction * sign(len[idx])

-            currentNode <- newNode

-        }

-    }else{

-        while(anyNA(x)) {

-            idx <- which(parent %in% currentNode)

-            newNode <- child[idx]

+        } else {

             x[newNode] <- x[parent[idx]]+len[idx] * direction

-            currentNode <- newNode

-        }        

+        }

+        currentNode <- newNode

     }

     return(x)

@@ -769,7 +769,7 @@ getXcoord2 <- function(x, root, parent, child, len, start=0, rev=FALSE) {

                   ifelse(sum(len < 0)>1, "edge lengths", "edge length"),

                   ". If you want to ignore the ", 

                   ifelse(sum(len<0) > 1, "edges", "edge"),

-                  "you can set 'options(ignore.negative.edge=TRUE)', then re-run ggtree."

+                  ", you can set 'options(ignore.negative.edge=TRUE)', then re-run ggtree."

         )

     }

@@ -764,13 +764,31 @@ getXcoord2 <- function(x, root, parent, child, len, start=0, rev=FALSE) {

         direction <- -1

     }

-    while(anyNA(x)) {

-        idx <- which(parent %in% currentNode)

-        newNode <- child[idx]

-        x[newNode] <- x[parent[idx]]+len[idx] * direction * sign(len[idx])

-        currentNode <- newNode

+    if (any(len < 0) && (is.null(getOption("ignore.negative.edge")) || !getOption("ignore.negative.edge"))){

+        warning_wrap("The tree contained negative ", 

+                  ifelse(sum(len < 0)>1, "edge lengths", "edge length"),

+                  ". If you want to ignore the ", 

+                  ifelse(sum(len<0) > 1, "edges", "edge"),

+                  "you can set 'options(ignore.negative.edge=TRUE)', then re-run ggtree."

+        )

     }

+    if (getOption("ignore.negative.edge", default=FALSE)){

+        while(anyNA(x)) {

+            idx <- which(parent %in% currentNode)

+            newNode <- child[idx]

+            x[newNode] <- x[parent[idx]]+len[idx] * direction * sign(len[idx])

+            currentNode <- newNode

+        }

+    }else{

+        while(anyNA(x)) {

+            idx <- which(parent %in% currentNode)

+            newNode <- child[idx]

+            x[newNode] <- x[parent[idx]]+len[idx] * direction

+            currentNode <- newNode

+        }        

+    }

+    

     return(x)

 }

@@ -767,7 +767,7 @@ getXcoord2 <- function(x, root, parent, child, len, start=0, rev=FALSE) {

     while(anyNA(x)) {

         idx <- which(parent %in% currentNode)

         newNode <- child[idx]

-        x[newNode] <- x[parent[idx]]+len[idx] * direction

+        x[newNode] <- x[parent[idx]]+len[idx] * direction * sign(len[idx])

         currentNode <- newNode

     }

@@ -1152,12 +1152,19 @@ add_angle_slanted <- function(res) {

 }

-calculate_branch_mid <- function(res) {

+calculate_branch_mid <- function(res, layout) {

+    if (layout %in% c("equal_angle", "daylight", "ape")){

+        res$branch.y <- with(res, (y[match(parent, node)] + y)/2)

+        res$branch.y[is.na(res$branch.y)] <- 0

+    }

     res$branch <- with(res, (x[match(parent, node)] + x)/2)

     if (!is.null(res[['branch.length']])) {

         res$branch.length[is.na(res$branch.length)] <- 0

     }

     res$branch[is.na(res$branch)] <- 0

+    if (layout %in% c("equal_angle", "daylight", "ape")){

+        res$branch.x <- res$branch

+    }

     return(res)

 }

@@ -1200,7 +1200,7 @@ layoutApe <- function(model, branch.length="branch.length") {

 	df <- as_tibble(model) %>%

 		mutate(isTip = ! .data$node %in% .data$parent)

-	df$branch.length <- edge.length[df$node] # for cladogram

+	#df$branch.length <- edge.length[df$node] # for cladogram

 	# unrooted layout from cran/ape

 	M <- ape::unrooted.xy(Ntip(tree),

@@ -46,7 +46,7 @@ layoutEqualAngle <- function(model, branch.length = "branch.length"){

           tree$edge.length <- NULL

       }

   }

-  

+

   if (is.null(tree$edge.length) || branch.length == "none") {

       tree <- set_branch_length_cladogram(tree)

   }

@@ -149,7 +149,7 @@ layoutEqualAngle <- function(model, branch.length = "branch.length"){

 ##' ```

 layoutDaylight <- function(model, branch.length, MAX_COUNT=5 ){

 	tree <- as.phylo(model)

-	

+

     ## How to set optimal

     MINIMUM_AVERAGE_ANGLE_CHANGE <- 0.05

@@ -454,7 +454,7 @@ rotateTreePoints.df <- function(df, pivot_node, nodes, angle){

   pivot_y = df$y[pivot_node]

   delta_x = df$x - pivot_x

   delta_y = df$y - pivot_y

-  df = mutate.data.frame(df,

+  df = mutate(df,

     x = ifelse(.data$node %in% nodes, cospitheta * delta_x - sinpitheta * delta_y + pivot_x, .data$x),

     y = ifelse(.data$node %in% nodes, sinpitheta * delta_x + cospitheta * delta_y + pivot_y, .data$y)

   )

@@ -464,7 +464,7 @@ rotateTreePoints.df <- function(df, pivot_node, nodes, angle){

   # angle is in range [0, 360]

   # Update label angle of tipnode if not root node.

   nodes = nodes[! nodes %in% df$parent]

-  df %>% mutate.data.frame(

+  df %>% mutate(

     angle = ifelse(.data$node %in% nodes,

        getNodeAngle.vector(x_parent, y_parent, .data$x, .data$y) %>%

          {180 * ifelse(. < 0, 2 + ., .)},

@@ -631,14 +631,6 @@ getRoot.df <- function(df, node){

   return(root)

 }

-

-

-mutate.data.frame <- getFromNamespace("mutate.data.frame", "dplyr")

-

-

-

-

-

 ##' Get the nodes of tree from root in breadth-first order.

 ##'

 ##' @title getNodesBreadthFirst.df

@@ -896,7 +888,7 @@ getYcoord <- function(tr, step=1, tip.order = NULL) {

         y[tip.idx] <- match(tr$tip.label, tip.order) * step

     }

     y[-tip.idx] <- NA

-    

+

     ## use lookup table

     pvec <- integer(max(tr$edge))

@@ -1190,26 +1182,26 @@ re_assign_ycoord_df <- function(df, currentNode) {

 layoutApe <- function(model, branch.length="branch.length") {

 	tree <- as.phylo(model) %>% stats::reorder("postorder")

-	

+

 	if (! is.null(tree$edge.length)) {

 		if (anyNA(tree$edge.length)) {

 			warning("'edge.length' contains NA values...\n## setting 'edge.length' to NULL automatically when plotting the tree...")

 			tree$edge.length <- NULL

 		}

 	}

-	

+

 	if (is.null(tree$edge.length) || branch.length == "none") {

 		tree <- set_branch_length_cladogram(tree)

 	}

-	

+

 	edge <- tree$edge

 	edge.length <- tree$edge.length

 	nb.sp <- ape::node.depth(tree)

-	

+

 	df <- as_tibble(model) %>%

 		mutate(isTip = ! .data$node %in% .data$parent)

 	df$branch.length <- edge.length[df$node] # for cladogram

-	

+

 	# unrooted layout from cran/ape

 	M <- ape::unrooted.xy(Ntip(tree),

 						  Nnode(tree),

@@ -1219,13 +1211,13 @@ layoutApe <- function(model, branch.length="branch.length") {

 						  0)$M

 	xx <- M[, 1]

 	yy <- M[, 2]

-	

+

 	M <- tibble::tibble(

 		node = 1:(Ntip(tree) + Nnode(tree)),

 		x = xx - min(xx),

 		y = yy - min(yy)

 	)

-	

+

 	tree_df <- dplyr::full_join(df, M, by = "node") %>%

 		as_tibble()

 	class(tree_df) <- c("tbl_tree", class(tree_df))

@@ -1124,7 +1124,8 @@ getYcoord_scale_category <- function(tr, df, yscale, yscale_mapping=NULL, ...) {

         yy <- df[[yscale]]

         ii <- which(is.na(yy))

         if (length(ii)) {

-            df[ii, yscale] <- df[ii, "node"]

+            ## df[ii, yscale] <- df[ii, "node"]

+            df[[yscale]][ii] <- as.character(df[['node']][ii])

         }

     }

@@ -610,7 +610,7 @@ getSubtreeUnrooted.df <- function(df, node){

   # The remaining nodes that are not found in the child subtrees are the remaining subtree nodes.

   # ie, parent node and all other nodes. We don't care how they are connected, just their id.

-  parent_id <- parent(df, node)$node

+  parent_id <- parent.tbl_tree(df, node)$node

   # If node is not root.

   if ((length(parent_id) > 0) & (length(remaining_nodes) > 0)) {

     subtrees = tibble::add_row(subtrees, node = parent_id, subtree = list(remaining_nodes))

@@ -598,7 +598,7 @@ getSubtreeUnrooted <- function(tree, node){

 getSubtreeUnrooted.df <- function(df, node){

   # get subtree for each child node.

                                         # children_ids <- getChild.df(df, node)

-    children_ids <- tidytree::child(df, node)$node

+    children_ids <- child.tbl_tree(df, node)$node

   if (length(children_ids) == 0L) return(NULL)

   # if node leaf, return nothing.

@@ -37,7 +37,7 @@ set_branch_length_cladogram <- function(tree) {

 ##' @param model tree object, e.g. phylo or treedata

 ##' @param branch.length set to 'none' for edge length of 1. Otherwise the phylogenetic tree edge length is used.

 ##' @return tree as data.frame with equal angle layout.

-layoutEqualAngle <- function(model, branch.length ){

+layoutEqualAngle <- function(model, branch.length = "branch.length"){

 	tree <- as.phylo(model)

   if (! is.null(tree$edge.length)) {

@@ -50,10 +50,11 @@ layoutEqualAngle <- function(model, branch.length ){

   if (is.null(tree$edge.length) || branch.length == "none") {

       tree <- set_branch_length_cladogram(tree)

   }

-  brlen <- numeric(getNodeNum(tree))

+  N <- treeio::Nnode2(tree)

+  brlen <- numeric(N)

   brlen[tree$edge[,2]] <- tree$edge.length

-  root <- getRoot(tree)

+  root <- tidytree::rootnode(tree)

   ## Convert Phylo tree to data.frame.

   ## df <- as.data.frame.phylo_(tree)

   df <- as_tibble(model) %>%

@@ -62,11 +63,11 @@ layoutEqualAngle <- function(model, branch.length ){

     ## NOTE: Angles (start, end, angle) are in half-rotation units (radians/pi or degrees/180)

     ## create and assign NA to the following fields.

-    df$x <- NA

-    df$y <- NA

-    df$start <- NA # Start angle of segment of subtree.

-    df$end   <- NA # End angle of segment of subtree

-    df$angle <- NA # Orthogonal angle to beta for tip labels.

+    df$x <- 0

+    df$y <- 0

+    df$start <- 0 # Start angle of segment of subtree.

+    df$end   <- 0 # End angle of segment of subtree

+    df$angle <- 0 # Orthogonal angle to beta for tip labels.

     ## Initialize root node position and angles.

     df[root, "x"] <- 0

     df[root, "y"] <- 0

@@ -77,12 +78,10 @@ layoutEqualAngle <- function(model, branch.length ){

     df$branch.length <- brlen[df$node] # for cladogram

-    N <- getNodeNum(tree)

-

     ## Get number of tips for each node in tree.

   ## nb.sp <- sapply(1:N, function(i) length(get.offspring.tip(tree, i)))

   ## self_include = TRUE to return itself if the input node is a tip

-  nb.sp <- sapply(1:N, function(i) length(offspring(tree, i, tiponly = TRUE, self_include = TRUE)))

+  nb.sp <- vapply(1:N, function(i) length(offspring(tree, i, tiponly = TRUE, self_include = TRUE)), numeric(1))

     ## Get list of node id's.

     nodes <- getNodes_by_postorder(tree)

@@ -1220,7 +1219,7 @@ layoutApe <- function(model, branch.length="branch.length") {

 	xx <- M[, 1]

 	yy <- M[, 2]

-	M <- tibble::data_frame(

+	M <- tibble::tibble(

 		node = 1:(Ntip(tree) + Nnode(tree)),

 		x = xx - min(xx),

 		y = yy - min(yy)

@@ -57,7 +57,7 @@ layoutEqualAngle <- function(model, branch.length ){

   ## Convert Phylo tree to data.frame.

   ## df <- as.data.frame.phylo_(tree)

   df <- as_tibble(model) %>%

-      mutate_(isTip = ~(! node %in% parent))

+      mutate(isTip = ! .data$node %in% .data$parent)

     ## NOTE: Angles (start, end, angle) are in half-rotation units (radians/pi or degrees/180)

@@ -1207,7 +1207,7 @@ layoutApe <- function(model, branch.length="branch.length") {

 	nb.sp <- ape::node.depth(tree)

 	df <- as_tibble(model) %>%

-		mutate_(isTip = ~(! node %in% parent))

+		mutate(isTip = ! .data$node %in% .data$parent)

 	df$branch.length <- edge.length[df$node] # for cladogram

 	# unrooted layout from cran/ape

@@ -455,7 +455,7 @@ rotateTreePoints.df <- function(df, pivot_node, nodes, angle){

   pivot_y = df$y[pivot_node]

   delta_x = df$x - pivot_x

   delta_y = df$y - pivot_y

-  df = dplyr::mutate(df,

+  df = mutate.data.frame(df,

     x = ifelse(.data$node %in% nodes, cospitheta * delta_x - sinpitheta * delta_y + pivot_x, .data$x),

     y = ifelse(.data$node %in% nodes, sinpitheta * delta_x + cospitheta * delta_y + pivot_y, .data$y)

   )

@@ -465,7 +465,7 @@ rotateTreePoints.df <- function(df, pivot_node, nodes, angle){

   # angle is in range [0, 360]

   # Update label angle of tipnode if not root node.

   nodes = nodes[! nodes %in% df$parent]

-  df %>% dplyr::mutate(

+  df %>% mutate.data.frame(

     angle = ifelse(.data$node %in% nodes,

        getNodeAngle.vector(x_parent, y_parent, .data$x, .data$y) %>%

          {180 * ifelse(. < 0, 2 + ., .)},

@@ -634,9 +634,7 @@ getRoot.df <- function(df, node){

-

-

-

+mutate.data.frame <- getFromNamespace("mutate.data.frame", "dplyr")

@@ -1189,8 +1189,9 @@ re_assign_ycoord_df <- function(df, currentNode) {

     return(df)

 }

+

 layoutApe <- function(model, branch.length="branch.length") {

-	tree <- as.phylo(model) %>% reorder("postorder")

+	tree <- as.phylo(model) %>% stats::reorder("postorder")

 	if (! is.null(tree$edge.length)) {

 		if (anyNA(tree$edge.length)) {

@@ -1192,38 +1192,39 @@ re_assign_ycoord_df <- function(df, currentNode) {

 layoutApe <- function(model, branch.length="branch.length") {

 	tree <- as.phylo(model) %>% reorder("postorder")

+	if (! is.null(tree$edge.length)) {

+		if (anyNA(tree$edge.length)) {

+			warning("'edge.length' contains NA values...\n## setting 'edge.length' to NULL automatically when plotting the tree...")

+			tree$edge.length <- NULL

+		}

+	}

+	

+	if (is.null(tree$edge.length) || branch.length == "none") {

+		tree <- set_branch_length_cladogram(tree)

+	}

+	

 	edge <- tree$edge

 	edge.length <- tree$edge.length

 	nb.sp <- ape::node.depth(tree)

 	df <- as_tibble(model) %>%

 		mutate_(isTip = ~(! node %in% parent))

+	df$branch.length <- edge.length[df$node] # for cladogram

+	

+	# unrooted layout from cran/ape

+	M <- ape::unrooted.xy(Ntip(tree),

+						  Nnode(tree),

+						  tree$edge,

+						  tree$edge.length,

+						  nb.sp,

+						  0)$M

+	xx <- M[, 1]

+	yy <- M[, 2]

-	# from ape

-	foo <- function(node, ANGLE, AXIS) {

-		ind <- which(edge[, 1] == node)

-		sons <- edge[ind, 2]

-		start <- AXIS - ANGLE/2

-		for (i in 1:length(sons)) {

-			h <- edge.length[ind[i]]

-			angle[sons[i]] <<- alpha <- ANGLE * nb.sp[sons[i]]/nb.sp[node]

-			axis[sons[i]] <<- beta <- start + alpha/2

-			start <- start + alpha

-			xx[sons[i]] <<- h * cos(beta) + xx[node]

-			yy[sons[i]] <<- h * sin(beta) + yy[node]

-		}

-		for (i in sons) if (i > Ntip(tree)) 

-			foo(i, angle[i], axis[i])

-	}

-	Nedge <- dim(edge)[1]

-	yy <- xx <- numeric(Ntip(tree) + Nnode(tree))

-	axis <- angle <- numeric(Ntip(tree) + Nnode(tree))

-	foo(Ntip(tree) + 1L, 2 * pi, 0)

 	M <- tibble::data_frame(

 		node = 1:(Ntip(tree) + Nnode(tree)),

 		x = xx - min(xx),

-		y = yy - min(yy),

-		angle = angle

+		y = yy - min(yy)

 	)

 	tree_df <- dplyr::full_join(df, M, by = "node") %>%

@@ -5,7 +5,8 @@ layout.unrooted <- function(model, branch.length="branch.length", layout.method=

     df <- switch(layout.method,

                  equal_angle = layoutEqualAngle(model, branch.length),

-                 daylight = layoutDaylight(model, branch.length, MAX_COUNT)

+                 daylight = layoutDaylight(model, branch.length, MAX_COUNT),

+    			 ape = layoutApe(model, branch.length)

                  )

     return(df)

@@ -1188,3 +1189,45 @@ re_assign_ycoord_df <- function(df, currentNode) {

     return(df)

 }

+layoutApe <- function(model, branch.length="branch.length") {

+	tree <- as.phylo(model) %>% reorder("postorder")

+	

+	edge <- tree$edge

+	edge.length <- tree$edge.length

+	nb.sp <- ape::node.depth(tree)

+	

+	df <- as_tibble(model) %>%

+		mutate_(isTip = ~(! node %in% parent))

+	

+	# from ape

+	foo <- function(node, ANGLE, AXIS) {

+		ind <- which(edge[, 1] == node)

+		sons <- edge[ind, 2]

+		start <- AXIS - ANGLE/2

+		for (i in 1:length(sons)) {

+			h <- edge.length[ind[i]]

+			angle[sons[i]] <<- alpha <- ANGLE * nb.sp[sons[i]]/nb.sp[node]

+			axis[sons[i]] <<- beta <- start + alpha/2

+			start <- start + alpha

+			xx[sons[i]] <<- h * cos(beta) + xx[node]

+			yy[sons[i]] <<- h * sin(beta) + yy[node]

+		}

+		for (i in sons) if (i > Ntip(tree)) 

+			foo(i, angle[i], axis[i])

+	}

+	Nedge <- dim(edge)[1]

+	yy <- xx <- numeric(Ntip(tree) + Nnode(tree))

+	axis <- angle <- numeric(Ntip(tree) + Nnode(tree))

+	foo(Ntip(tree) + 1L, 2 * pi, 0)

+	M <- tibble::data_frame(

+		node = 1:(Ntip(tree) + Nnode(tree)),

+		x = xx - min(xx),

+		y = yy - min(yy),

+		angle = angle

+	)

+	

+	tree_df <- dplyr::full_join(df, M, by = "node") %>%

+		as_tibble()

+	class(tree_df) <- c("tbl_tree", class(tree_df))

+	tree_df

+}

@@ -290,13 +290,13 @@ applyLayoutDaylight <- function(df, node_id){

 ##' Find the right (clockwise rotation, angle from +ve x-axis to furthest subtree nodes) and

-##' left (anti-clockwise angle from +ve x-axis to subtree) Returning arc angle in [0, 2] (0 to 360) domain.

+##' left (anti-clockwise angle from +ve x-axis to subtree) Returning arc angle in `[0, 2]` (0 to 360) domain.

 ##'

 ##' @title getTreeArcAngles

 ##' @param df tree data.frame

 ##' @param origin_id node id from which to calculate left and right hand angles of subtree.

 ##' @param subtree named list of root id of subtree (node) and list of node ids for given subtree (subtree).

-##' @return named list with right and left angles in range [0,2] i.e 1 = 180 degrees, 1.5 = 270 degrees.

+##' @return named list with right and left angles in range `[0,2]` i.e 1 = 180 degrees, 1.5 = 270 degrees.

 getTreeArcAngles <- function(df, origin_id, subtree) {

     df_x = df$x

     df_y = df$y

@@ -437,11 +437,12 @@ getTreeArcAngles <- function(df, origin_id, subtree) {

 ##' Rotate the points in a tree data.frame around a pivot node by the angle specified.

 ##'

-##' @title rotateTreePoints.data.fram

+##' @title rotateTreePoints.data.frame

+##' @rdname rotateTreePoints

 ##' @param df tree data.frame

 ##' @param pivot_node is the id of the pivot node.

 ##' @param nodes list of node numbers that are to be rotated by angle around the pivot_node

-##' @param angle in range [0,2], ie degrees/180, radians/pi

+##' @param angle in range `[0,2]`, ie degrees/180, radians/pi

 ##' @return updated tree data.frame with points rotated by angle

 rotateTreePoints.df <- function(df, pivot_node, nodes, angle){

   # Rotate nodes around pivot_node.

@@ -477,7 +478,7 @@ rotateTreePoints.df <- function(df, pivot_node, nodes, angle){

 ##' @param df tree data.frame

 ##' @param origin_node_id origin node id number

 ##' @param node_id end node id number

-##' @return angle in range [-1, 1], i.e. degrees/180, radians/pi

+##' @return angle in range `[-1, 1]`, i.e. degrees/180, radians/pi

 getNodeAngle.df <- function(df, origin_node_id, node_id){

   if (origin_node_id != node_id) {

     df_x = df$x

@@ -876,7 +876,7 @@ getXcoord <- function(tr) {

 ## @importFrom magrittr %>%

 ##' @importFrom magrittr equals

-getYcoord <- function(tr, step=1) {

+getYcoord <- function(tr, step=1, tip.order = NULL) {

     Ntip <- length(tr[["tip.label"]])

     N <- getNodeNum(tr)

@@ -889,9 +889,15 @@ getYcoord <- function(tr, step=1) {

     child_list[as.numeric(names(cl))] <- cl

     y <- numeric(N)

-    tip.idx <- child[child <= Ntip]

-    y[tip.idx] <- 1:Ntip * step

+    if (is.null(tip.order)) {

+        tip.idx <- child[child <= Ntip]

+        y[tip.idx] <- 1:Ntip * step

+    } else {

+        tip.idx <- 1:Ntip

+        y[tip.idx] <- match(tr$tip.label, tip.order) * step

+    }

     y[-tip.idx] <- NA

+    

     ## use lookup table

     pvec <- integer(max(tr$edge))

@@ -538,7 +538,8 @@ getSubtree.df <- function(df, node){

   ##   i <- i + 1

   ## }

     ## subtree

-    tidytree:::offspring.tbl_tree(df, node, self_include = TRUE)$node

+    #tidytree:::offspring.tbl_tree(df, node, self_include = TRUE)$node

+    offspring.tbl_tree(df, node, self_include = TRUE)$node

 }

 ##' Get all subtrees of specified node. This includes all ancestors and relatives of node and

@@ -309,7 +309,7 @@ getTreeArcAngles <- function(df, origin_id, subtree) {

     ## Initialise angle from origin node to parent node.

     ## If subtree_root_id is child of origin_id

     ## if (subtree_root_id %in% getChild.df(df, origin_id)) {

-    if (subtree_root_id %in% tidytree::child(df, origin_id)$node) {

+    if (subtree_root_id %in% tidytree:::child.tbl_tree(df, origin_id)$node) {

         ## get angle from original node to parent of subtree.

         theta_left <- getNodeAngle.vector(x_origin, y_origin, df_x[subtree_root_id], df_y[subtree_root_id])

         theta_right <- theta_left

@@ -317,7 +317,7 @@ getTreeArcAngles <- function(df, origin_id, subtree) {

         ## Special case.

         ## get angle from parent of subtree to children

         ## children_ids <- getChild.df(df, subtree_root_id)

-        children_ids <- tidytree::child(df, subtree_root_id)$node

+        children_ids <- tidytree:::child.tbl_tree(df, subtree_root_id)$node

         if(length(children_ids) == 2){

             ## get angles from parent to it's two children.

             theta1 <- getNodeAngle.vector(x_origin, y_origin, df_x[children_ids[1]], df_y[children_ids[1]])

@@ -372,7 +372,7 @@ getTreeArcAngles <- function(df, origin_id, subtree) {

     # Get angle from origin node to parent node.

     theta_parent <- getNodeAngle.vector(x_origin, y_origin, df_x[parent_id], df_y[parent_id])

       ## children_ids <- getChild.df(df, parent_id)

-      children_ids <- tidytree::child(df, parent_id)$node

+      children_ids <- tidytree:::child.tbl_tree(df, parent_id)$node

     # Skip if child is parent node of subtree.

     children_ids = children_ids[children_ids != origin_id]

     for(child_id in children_ids){

@@ -678,38 +678,6 @@ getNodesBreadthFirst.df <- function(df){

 }

-

-##' convert tip or node label(s) to internal node number

-##'

-##'

-##' @title nodeid

-##' @param x tree object or graphic object return by ggtree

-##' @param label tip or node label(s)

-##' @return internal node number

-##' @importFrom methods is

-##' @export

-##' @author Guangchuang Yu

-nodeid <- function(x, label) {

-    if (is(x, "gg"))

-        return(nodeid.gg(x, label))

-

-    nodeid.tree(x, label)

-}

-

-nodeid.tree <- function(tree, label) {

-    tr <- get.tree(tree)

-    lab <- c(tr$tip.label, tr$node.label)

-    match(label, lab)

-}

-

-nodeid.gg <- function(p, label) {

-    p$data$node[match(label, p$data$label)]

-}

-

-

-

-

-

 isRoot <- function(tr, node) {

     getRoot(tr) == node

 }

@@ -357,11 +357,11 @@ getTreeArcAngles <- function(df, origin_id, subtree) {

   # no parent angle found.

   # Subtree has to have 1 or more nodes to compare.

   if (is.na(theta_left) || (length(subtree_node_ids) == 0)){

-    return(0)

+      return(c('left' = 0, 'right' = 0))

   }

   # create vector with named columns

   # left-hand and right-hand angles between origin node and the extremities of the tree nodes.

-  arc <- c('left' = theta_left, 'right' = theta_right)

+    arc <- c('left' = theta_left, 'right' = theta_right)

   # Calculate the angle from the origin node to each child node.

   # Moving from parent to children in depth-first traversal.

@@ -80,7 +80,8 @@ layoutEqualAngle <- function(model, branch.length ){

     ## Get number of tips for each node in tree.

   ## nb.sp <- sapply(1:N, function(i) length(get.offspring.tip(tree, i)))

-  nb.sp <- sapply(1:N, function(i) length(offspring(tree, i, tiponly = TRUE)))

+  ## self_include = TRUE to return itself if the input node is a tip

+  nb.sp <- sapply(1:N, function(i) length(offspring(tree, i, tiponly = TRUE, self_include = TRUE)))

     ## Get list of node id's.

     nodes <- getNodes_by_postorder(tree)

@@ -88,7 +89,8 @@ layoutEqualAngle <- function(model, branch.length ){

         ## Get number of tips for current node.

         curNtip <- nb.sp[curNode]

         ## Get array of child node indexes of current node.

-        children <- getChild(tree, curNode)

+        ## children <- getChild(tree, curNode)

+        children <- treeio::child(tree, curNode)

         ## Get "start" and "end" angles of a segment for current node in the data.frame.

         start <- df[curNode, "start"]

@@ -120,7 +122,9 @@ layoutEqualAngle <- function(model, branch.length ){

             start <- start + alpha

         }

     }

-    df

+  tree_df <- as_tibble(df)

+  class(tree_df) <- c("tbl_tree", class(tree_df))

+  return(tree_df)

 }

 ##' Equal daylight layout method for unrooted trees.

@@ -182,8 +186,9 @@ layoutDaylight <- function(model, branch.length, MAX_COUNT=5 ){

         if (ave_change <= MINIMUM_AVERAGE_ANGLE_CHANGE) break

     }

-    return(tree_df)

-

+  tree_df <- as_tibble(tree_df)

+  class(tree_df) <- c("tbl_tree", class(tree_df))

+  return(tree_df)

 }

 ##' Apply the daylight alorithm to adjust the spacing between the subtrees and tips of the

@@ -303,14 +308,16 @@ getTreeArcAngles <- function(df, origin_id, subtree) {

     subtree_node_ids <- subtree$subtree

     ## Initialise angle from origin node to parent node.

     ## If subtree_root_id is child of origin_id

-    if (subtree_root_id %in% getChild.df(df, origin_id)) {

+    ## if (subtree_root_id %in% getChild.df(df, origin_id)) {

+    if (subtree_root_id %in% tidytree::child(df, origin_id)$node) {

         ## get angle from original node to parent of subtree.

         theta_left <- getNodeAngle.vector(x_origin, y_origin, df_x[subtree_root_id], df_y[subtree_root_id])

         theta_right <- theta_left

     } else if( subtree_root_id == origin_id ){

         ## Special case.

         ## get angle from parent of subtree to children

-        children_ids <- getChild.df(df, subtree_root_id)

+        ## children_ids <- getChild.df(df, subtree_root_id)

+        children_ids <- tidytree::child(df, subtree_root_id)$node

         if(length(children_ids) == 2){

             ## get angles from parent to it's two children.

             theta1 <- getNodeAngle.vector(x_origin, y_origin, df_x[children_ids[1]], df_y[children_ids[1]])

@@ -364,7 +371,8 @@ getTreeArcAngles <- function(df, origin_id, subtree) {

   for(parent_id in subtree_node_ids){

     # Get angle from origin node to parent node.

     theta_parent <- getNodeAngle.vector(x_origin, y_origin, df_x[parent_id], df_y[parent_id])

-    children_ids <- getChild.df(df, parent_id)

+      ## children_ids <- getChild.df(df, parent_id)

+      children_ids <- tidytree::child(df, parent_id)$node

     # Skip if child is parent node of subtree.

     children_ids = children_ids[children_ids != origin_id]

     for(child_id in children_ids){

@@ -503,15 +511,16 @@ getNodeEuclDistances <- function(df, node){

 ##' @return list of all child node id's from starting node.

 getSubtree <- function(tree, node){

-  subtree <- c(node)

-  i <- 1

-  while( i <= length(subtree)){

-    subtree <- c(subtree, getChild(tree, subtree[i]))

-    # remove any '0' root nodes

-    subtree <- subtree[subtree != 0]

-    i <- i + 1

-  }

-  return(subtree)

+  ## subtree <- c(node)

+  ## i <- 1

+  ## while( i <= length(subtree)){

+  ##   subtree <- c(subtree, treeio::child(tree, subtree[i]))

+  ##   # remove any '0' root nodes

+  ##   subtree <- subtree[subtree != 0]

+  ##   i <- i + 1

+  ## }

+    ## return(subtree)

+    tidytree::offspring(tree, node, self_include = TRUE)

 }

 ##' Get all children of node from df tree using breath-first.

@@ -521,13 +530,15 @@ getSubtree <- function(tree, node){

 ##' @param node id of starting node.

 ##' @return list of all child node id's from starting node.

 getSubtree.df <- function(df, node){

-  subtree <- node[node != 0]

-  i <- 1

-  while( i <= length(subtree)){

-    subtree <- c(subtree, getChild.df(df, subtree[i]))

-    i <- i + 1

-  }

-  subtree

+  ## subtree <- node[node != 0]

+  ## i <- 1

+  ## while( i <= length(subtree)){

+  ##     ## subtree <- c(subtree, getChild.df(df, subtree[i]))

+  ##     subtree <- c(subtree, tidytree::child(df, subtree[i])$node)

+  ##   i <- i + 1

+  ## }

+    ## subtree

+    tidytree:::offspring.tbl_tree(df, node, self_include = TRUE)$node

 }

 ##' Get all subtrees of specified node. This includes all ancestors and relatives of node and

@@ -539,7 +550,7 @@ getSubtree.df <- function(df, node){

 ##' @return named list of subtrees with the root id of subtree and list of node id's making up subtree.

 getSubtreeUnrooted <- function(tree, node){

   # if node leaf, return nothing.

-  if( isTip(tree, node) ){

+  if( treeio::isTip(tree, node) ){

     # return NA

     return(NA)

   }

@@ -547,7 +558,8 @@ getSubtreeUnrooted <- function(tree, node){

   subtrees <- list()

   # get subtree for each child node.

-  children_ids <- getChild(tree, node)

+    ## children_ids <- getChild(tree, node)

+    children_ids <- treeio::child(tree, node)

   remaining_nodes <- getNodes_by_postorder(tree)

   # Remove current node from remaining_nodes list.

@@ -564,7 +576,7 @@ getSubtreeUnrooted <- function(tree, node){

   # The remaining nodes that are not found in the child subtrees are the remaining subtree nodes.

   # ie, parent node and all other nodes. We don't care how they are connect, just their ids.

-  parent_id <- getParent(tree, node)

+  parent_id <- parent(tree, node)

   # If node is not root, add remainder of tree nodes as subtree.

   if( parent_id != 0 & length(remaining_nodes) >= 1){

     subtrees[[length(subtrees)+1]] <- list( node = parent_id, subtree = remaining_nodes)

@@ -579,10 +591,12 @@ getSubtreeUnrooted <- function(tree, node){

 ##' @title getSubtreeUnrooted

 ##' @param df tree data.frame

 ##' @param node is the tree node id from which the subtrees are derived.

+##' @importFrom tidytree parent

 ##' @return named list of subtrees with the root id of subtree and list of node id's making up subtree.

 getSubtreeUnrooted.df <- function(df, node){

   # get subtree for each child node.

-  children_ids <- getChild.df(df, node)

+                                        # children_ids <- getChild.df(df, node)

+    children_ids <- tidytree::child(df, node)$node

   if (length(children_ids) == 0L) return(NULL)

   # if node leaf, return nothing.

@@ -594,7 +608,7 @@ getSubtreeUnrooted.df <- function(df, node){

   # The remaining nodes that are not found in the child subtrees are the remaining subtree nodes.

   # ie, parent node and all other nodes. We don't care how they are connected, just their id.

-  parent_id <- getParent.df(df, node)

+  parent_id <- parent(df, node)$node

   # If node is not root.

   if ((length(parent_id) > 0) & (length(remaining_nodes) > 0)) {

     subtrees = tibble::add_row(subtrees, node = parent_id, subtree = list(remaining_nodes))

@@ -622,19 +636,6 @@ getRoot.df <- function(df, node){

-isTip <- function(tr, node) {

-  children_ids <- getChild(tr, node)

-  #length(children_ids) == 0 ## getChild returns 0 if nothing found.

-  return( length(children_ids) == 0 | any(children_ids == 0) )

-}

-

-isTip.df <- function(df, node) {

-  # df may not have the isTip structure.

-  # return(df[node, 'isTip'])