Java Node.getChildren方法代码示例

import beast.evolution.tree.Node; //导入方法依赖的package包/类
public Tree mutateOverTree(Tree base) throws Exception {
	ArrayList<Node> currParents = new ArrayList<Node>();
	ArrayList<Node> newParents = new ArrayList<Node>();
	currParents.add(base.getRoot());
	while (currParents.size() > 0) {
		for (Node parent : currParents) {
			List<Node> children = parent.getChildren();
			for (Node child : children) {
				double T = Math.abs(child.getHeight() - parent.getHeight());
				Sequence parentLang = getSequence(parent);
				Sequence newLang = mutateLang(parentLang, T);
				child.setMetaData("lang", newLang);
				newParents.add(child);
				addEmptyTrait(base, child);
			}
		}
		currParents = new ArrayList<Node>(newParents);
		newParents = new ArrayList<Node>();
	}
	return base;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
public Tree mutateOverTree(Tree base) throws Exception {
	ArrayList<Node> currParents = new ArrayList<Node>();
	ArrayList<Node> newParents = new ArrayList<Node>();
	currParents.add(base.getRoot());
	while (currParents.size() > 0) {
		for (Node parent : currParents) {
			List<Node> children = parent.getChildren();
			for (Node child : children) {
				double T = Math.abs(child.getHeight() - parent.getHeight());
				Sequence parentLang = getSequence(parent);
				Sequence newLang = mutateLang(parentLang, T);
				child.setMetaData("lang", newLang);
				newParents.add(child);
			}
		}
		currParents = new ArrayList<Node>(newParents);
		newParents = new ArrayList<Node>();
	}
	return base;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
void setTipValues(Node node) {
    if (node.isLeaf()) {
        node.setMetaData("p", p);
        node.setMetaData("p_min", p);
        node.setMetaData("p_max", p);
        p += getCanonicalNodeSpacing(node.getTree());
    } else {
        double pmin = Double.MAX_VALUE;
        double pmax = Double.MIN_VALUE;
        for (Node childNode : node.getChildren()) {
            setTipValues(childNode);

            double cpmin = (Double) childNode.getMetaData("p_min");
            double cpmax = (Double) childNode.getMetaData("p_max");

            if (cpmin < pmin) pmin = cpmin;
            if (cpmax > pmax) pmax = cpmax;
        }
        node.setMetaData("p_min", pmin);
        node.setMetaData("p_max", pmax);
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
/**
 * Use zero-length edges to replace multifurcations with a sequence of bifurcations.
 *
 * @param node node representing multifurcation
 */
private void binarizeMultifurcation(Node node) {
     if (node.getChildCount()>2) {
        List<Node> children = new ArrayList<>(node.getChildren());
        Node prevDummy = node;
        for (int i=1; i<children.size()-1; i++) {
            Node child = children.get(i);

            Node dummyNode = newNode();
            dummyNode.setNr(-1);
            dummyNode.setHeight(0);
            prevDummy.addChild(dummyNode);

            node.removeChild(child);
            dummyNode.addChild(child);

            prevDummy = dummyNode;
        }
        node.removeChild(children.get(children.size()-1));
        prevDummy.addChild(children.get(children.size()-1));
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
/**
 * Extract the sampled tree by discarding all the nodes that have -1 number simultaneously suppress single
 * child nodes (nodes with only one child numbered by non-negative number)
 * @param node
 */
public void removeSingleChildNodes(Node node) {
    if (!node.isLeaf()) {
        Node left = node.getLeft();
        Node right = node.getRight();

        removeSingleChildNodes(left);
        removeSingleChildNodes(right);
        for (Node child:node.getChildren()) {
            if (child.getNr() == -1) {
                node.removeChild(child);
            }
        }
        if (node.getChildCount() == 1 && node.getParent() != null) {
            Node parent = node.getParent();
            Node newChild =  node.getLeft();
            parent.removeChild(node);
            parent.addChild(newChild);
            newChild.setParent(parent);
            //node.setParent(null);
        }
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
public ArrayList<Node> getAliveNodes(Tree base, Double t) {
	ArrayList<Node> aliveNodes = new ArrayList<Node>();

	Node root = base.getRoot();
	for (Node child : root.getChildren()) {
		if (child.getHeight() <= t) {
			aliveNodes.add(child);
		} else {
			aliveNodes.addAll(aliveNodes(child, t));
		}
	}

	return aliveNodes;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
protected ArrayList<Node> aliveNodes(Node curr, Double t) {
	ArrayList<Node> aN = new ArrayList<Node>();
	for (Node child : curr.getChildren()) {
		if (child.getHeight() <= t) {
			aN.add(child);
		} else {
			aN.addAll(aliveNodes(child, t));
		}
	}
	return aN;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
private double calcMinHeight(Node node) {
	if (node.isLeaf()) {
		return node.getHeight();
	}
	
	double minHeight = 0.0;
	for (Node child: node.getChildren()) {
		minHeight = Math.max(minHeight, calcMinHeight(child));
	}
	
	return minHeight;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
private void scaleAndTranslatePositions(Node node, double scale, double tx, double ty) {
    Point2D p = (Point2D) node.getMetaData("p");

    node.setMetaData("p", new Point2D.Double(p.getX() * scale + tx, p.getY() * scale + ty));

    for (Node child : node.getChildren()) {
        scaleAndTranslatePositions(child, scale, tx, ty);
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
void positionInternalNodes(Node node) {
    if (!node.isLeaf()) {
        if (positioningRule.getTraversalOrder() == NodePositioningRule.TraversalOrder.PRE_ORDER) {
            positioningRule.setPosition(node, "p");
        }
        for (Node child : node.getChildren()) {
            positionInternalNodes(child);
        }
        if (positioningRule.getTraversalOrder() == NodePositioningRule.TraversalOrder.POST_ORDER) {
            positioningRule.setPosition(node, "p");
        }

    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
private void processMetaData(Node node) {
	for (Node child : node.getChildren()) {
		processMetaData(child);
	}
	Set<String> metaDataNames = node.getMetaDataNames(); 
	if (metaDataNames != null && !metaDataNames.isEmpty()) {
		String metadata = "";
		for (String name : metaDataNames) {
			Object value = node.getMetaData(name);
			metadata += name + "=";
			if (value instanceof Object[]) {
				Object [] values = (Object[]) value;
				metadata += "{";
				for (int i = 0; i < values.length; i++) {
					metadata += values[i].toString();
					if (i < values.length - 1) {
						metadata += ",";
					}
				}
				metadata += "}";
			} else {
				 metadata += value.toString();
			}
			metadata += ",";
		}
		metadata = metadata.substring(0, metadata.length() - 1);
		node.metaDataString = metadata;
	}		
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
/**
 * Recursive method used to convert lengths to heights.  Applied to the root,
 * results in heights from 0 to -total_height_of_tree.
 *
 * @param node node of a clade to convert
 * @param height Parent height.
 * @return total height of clade
 */
private double convertLengthToHeight(final Node node, final double height) {
    final double length = node.getHeight();
    node.setHeight((height - length) * scaleInput.get());
    if (node.isLeaf()) {
        return node.getHeight();
    } else {
        double minChildHeight = Double.POSITIVE_INFINITY;
        for (Node child : node.getChildren())
            minChildHeight = Math.min(minChildHeight, convertLengthToHeight(child, height - length));

        return minChildHeight;
    }
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
/**
 * Method used by convertLengthToHeight(node) to remove negative offset from
 * node heights that is produced by convertLengthToHeight(node, height).
 *
 * @param node node of clade to offset
 * @param delta offset
 */
private void offset(final Node node, final double delta) {
    node.setHeight(node.getHeight() + delta);
    if (node.isLeaf()) {
        if (node.getHeight() < thresholdInput.get()) {
            node.setHeight(0);
        }
    }
    for (Node child : node.getChildren())
        offset(child, delta);
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
/**
 * Number any nodes in a clade which were not explicitly numbered by
 * the parsed string.
 *
 * @param node clade parent
 */
private void numberUnnumberedNodes(Node node) {
    if (node.isLeaf())
        return;

    for (Node child : node.getChildren()) {
        numberUnnumberedNodes(child);
    }

    if (node.getNr()<0)
        node.setNr(numberedNodeCount);

    numberedNodeCount += 1;
}
 

import beast.evolution.tree.Node; //导入方法依赖的package包/类
private ArrayList<String> listSampledNodeIDsUnder(Node node) {
    ArrayList<String> tmp = new ArrayList<String>();
    if (!node.isLeaf()) {
        for (Node child : node.getChildren()) {
            tmp.addAll(listSampledNodeIDsUnder(child));
        }
    } else tmp.add(node.getID());
    Collections.sort(tmp);
    return tmp;
}