2 // FORESTER -- software libraries and applications
3 // for evolutionary biology research and applications.
5 // Copyright (C) 2008-2009 Christian M. Zmasek
6 // Copyright (C) 2008-2009 Burnham Institute for Medical Research
7 // Copyright (C) 2000-2001 Washington University School of Medicine
8 // and Howard Hughes Medical Institute
11 // This library is free software; you can redistribute it and/or
12 // modify it under the terms of the GNU Lesser General Public
13 // License as published by the Free Software Foundation; either
14 // version 2.1 of the License, or (at your option) any later version.
16 // This library is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 // Lesser General Public License for more details.
21 // You should have received a copy of the GNU Lesser General Public
22 // License along with this library; if not, write to the Free Software
23 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
25 // Contact: phylosoft @ gmail . com
26 // WWW: www.phylosoft.org/forester
28 package org.forester.phylogeny;
30 import java.util.ArrayList;
31 import java.util.List;
33 import org.forester.io.parsers.nhx.NHXFormatException;
34 import org.forester.io.parsers.nhx.NHXParser;
35 import org.forester.io.parsers.phyloxml.PhyloXmlDataFormatException;
36 import org.forester.io.parsers.phyloxml.PhyloXmlUtil;
37 import org.forester.phylogeny.data.BranchData;
38 import org.forester.phylogeny.data.Confidence;
39 import org.forester.phylogeny.data.NodeData;
40 import org.forester.phylogeny.data.PhylogenyDataUtil;
41 import org.forester.phylogeny.iterators.PreorderTreeIterator;
42 import org.forester.util.ForesterUtil;
45 * Warning. Implementation of method 'compareTo' only looks at
46 * node name. Thus, use of this class in SortedSets might lead
47 * to unexpected behavior.
50 public final class PhylogenyNode implements PhylogenyNodeI, Comparable<PhylogenyNode> {
52 private static int _node_count = 0;
53 private byte _indicator;
55 private int _sum_ext_nodes;
58 private double _distance_parent = PhylogenyDataUtil.BRANCH_LENGTH_DEFAULT;
59 private boolean _collapse;
60 private PhylogenyNode _parent;
61 private PhylogenyNode _link;
62 private ArrayList<PhylogenyNode> _descendants;
63 private NodeData _node_data;
64 private BranchData _branch_data;
65 private float _x_secondary;
66 private float _y_secondary;
69 * Default constructor for PhylogenyNode.
71 public PhylogenyNode() {
73 setId( PhylogenyNode.getNodeCount() );
74 PhylogenyNode.increaseNodeCount();
75 setSumExtNodes( 1 ); // For ext node, this number is 1 (not 0!!)
78 public void removeConnections() {
85 * Adds PhylogenyNode n to the list of child nodes and sets the _parent of n
89 * the PhylogenyNode to add
92 final public void addAsChild( final PhylogenyNodeI node ) {
93 final PhylogenyNode n = ( PhylogenyNode ) node;
99 * Adds PhylogenyNode n to the list of child nodes. But does NOT set the
100 * _parent of n to this.
102 * @see addAsChild( PhylogenyNode n )
104 * the PhylogenyNode to add
106 final private void addChildNode( final PhylogenyNode child ) {
107 getDescendants().add( child );
111 // this is poor, as it only compares on names!
112 final public int compareTo( final PhylogenyNode o ) {
113 final PhylogenyNode n = o;
114 if ( ( getName() == null ) || ( n.getName() == null ) ) {
117 return getName().compareTo( n.getName() );
120 // ---------------------------------------------------------
121 // Copy and delete Nodes, copy subtress
122 // ---------------------------------------------------------
124 * Returns a new PhylogenyNode which has its data copied from this
125 * PhylogenyNode. Links to the other Nodes in the same Phylogeny are NOT
126 * copied (e.g. _link to _parent). Field "_link" IS copied.
130 final public PhylogenyNode copyNodeData() {
131 final PhylogenyNode node = new PhylogenyNode();
132 PhylogenyNode.decreaseNodeCount();
134 node._sum_ext_nodes = _sum_ext_nodes;
135 node._indicator = _indicator;
138 node._distance_parent = _distance_parent;
139 node._collapse = _collapse;
141 if ( _node_data != null ) {
142 node._node_data = ( NodeData ) _node_data.copy();
144 if ( _branch_data != null ) {
145 node._branch_data = ( BranchData ) _branch_data.copy();
151 * Returns a new PhylogenyNode which has the same data as this
152 * PhylogenyNode. Links to the other Nodes in the same Phylogeny are NOT
153 * copied (e.g. _link to _parent). Field "_link" IS copied.
157 final public PhylogenyNode copyNodeDataShallow() {
158 final PhylogenyNode node = new PhylogenyNode();
159 PhylogenyNode.decreaseNodeCount();
161 node._sum_ext_nodes = _sum_ext_nodes;
162 node._indicator = _indicator;
165 node._distance_parent = _distance_parent;
166 node._collapse = _collapse;
168 node._node_data = _node_data;
169 node._branch_data = _branch_data;
175 * Based on node name, sequence, and taxonomy.
179 final public boolean equals( final Object o ) {
183 else if ( o == null ) {
186 else if ( o.getClass() != this.getClass() ) {
187 throw new IllegalArgumentException( "attempt to check [" + this.getClass() + "] equality to " + o + " ["
188 + o.getClass() + "]" );
191 final PhylogenyNode other = ( PhylogenyNode ) o;
192 if ( !getName().equals( other.getName() ) ) {
195 final NodeData this_data = getNodeData();
196 final NodeData other_data = other.getNodeData();
197 if ( ( this_data.isHasSequence() && other_data.isHasSequence() )
198 && ( this_data.isHasTaxonomy() && other_data.isHasTaxonomy() ) ) {
199 return ( this_data.getTaxonomy().isEqual( other_data.getTaxonomy() ) && this_data.getSequence()
200 .isEqual( other_data.getSequence() ) );
202 else if ( this_data.isHasTaxonomy() && other_data.isHasTaxonomy() ) {
203 return ( this_data.getTaxonomy().isEqual( other_data.getTaxonomy() ) );
205 else if ( this_data.isHasSequence() && other_data.isHasSequence() ) {
206 return ( this_data.getSequence().isEqual( other_data.getSequence() ) );
208 else if ( getName().length() > 0 ) {
209 // Node name is not empty, and equal.
218 // ---------------------------------------------------------
219 // Obtaining of Nodes
220 // ---------------------------------------------------------
222 * Returns a List containing references to all external children of this
225 * @return List of references to external Nodes
227 final public List<PhylogenyNode> getAllExternalDescendants() {
228 final List<PhylogenyNode> nodes = new ArrayList<PhylogenyNode>();
229 if ( isExternal() ) {
233 PhylogenyNode node1 = this;
234 while ( !node1.isExternal() ) {
235 node1 = node1.getFirstChildNode();
237 PhylogenyNode node2 = this;
238 while ( !node2.isExternal() ) {
239 node2 = node2.getLastChildNode();
241 while ( node1 != node2 ) {
243 node1 = node1.getNextExternalNode();
250 * Returns a List containing references to all names of the external
251 * children of this PhylogenyNode.
253 * @return List of references to names of external Nodes
255 final public List<String> getAllExternalDescendantsNames() {
256 final List<PhylogenyNode> c = getAllExternalDescendants();
257 final List<String> n = new ArrayList<String>( c.size() );
258 for( final PhylogenyNode phylogenyNode : c ) {
259 n.add( phylogenyNode.getName() );
264 final public BranchData getBranchData() {
265 if ( _branch_data == null ) {
266 _branch_data = new BranchData();
271 final BranchData getBranchDataDirectly() {
276 * This return child node n of this node.
279 * the index of the child to get
280 * @return the child node with index n
281 * @throws IllegalArgumentException
282 * if n is out of bounds
285 final public PhylogenyNode getChildNode( final int i ) {
286 if ( isExternal() ) {
287 throw new UnsupportedOperationException( "attempt to get the child node of an external node." );
289 if ( ( i >= getNumberOfDescendants() ) || ( i < 0 ) ) {
290 throw new IllegalArgumentException( "attempt to get child node " + i + " of a node with "
291 + getNumberOfDescendants() + " child nodes" );
293 return getDescendants().get( i );
297 * Convenience method. Returns the first child PhylogenyNode of this
300 final public PhylogenyNode getChildNode1() {
301 return getChildNode( 0 );
305 * Convenience method. Returns the second child PhylogenyNode of this
308 * [last modified May 18, 2005 by CMZ]
310 final public PhylogenyNode getChildNode2() {
311 return getChildNode( 1 );
315 * This gets the child node index of this node.
318 * @return the child node index of this node
319 * @throws UnsupportedOperationException
320 * if this node is a root node
322 final public int getChildNodeIndex() {
323 return getChildNodeIndex( getParent() );
327 * This gets the child node index of this node, given that parent is its
330 * [last modified Aug 14, 2006 by CMZ]
332 * @return the child node index of this node
333 * @throws UnsupportedOperationException
334 * if this node is a root node
336 final public int getChildNodeIndex( final PhylogenyNode parent ) {
338 throw new UnsupportedOperationException( "Cannot get the child index for a root node." );
340 for( int i = 0; i < parent.getNumberOfDescendants(); ++i ) {
341 if ( parent.getChildNode( i ) == this ) {
345 throw new RuntimeException( "Unexpected exception: Could not determine the child index for node: " + this );
348 final public List<PhylogenyNode> getDescendants() {
349 if ( _descendants == null ) {
350 _descendants = new ArrayList<PhylogenyNode>();
356 * Returns the length of the branch leading to the _parent of this
357 * PhylogenyNode (double).
360 final public double getDistanceToParent() {
361 return _distance_parent;
365 * Convenience method. Returns the first child node of this node.
367 * [last modified May 18, 2005 by CMZ]
369 * @return the first child node of this node
371 public final PhylogenyNode getFirstChildNode() {
372 return getChildNode( 0 );
376 * Returns the _indicator value of this PhylogenyNode.
378 public final byte getIndicator() {
383 * Convenience method. Returns the last child node of this node.
385 * [last modified May 18, 2005 by CMZ]
387 * @return the last child node of this node
389 public final PhylogenyNode getLastChildNode() {
390 return getChildNode( getNumberOfDescendants() - 1 );
394 * Returns a refernce to the linked PhylogenyNode of this PhylogenyNode.
395 * Currently, this method is only used for the speciation-_duplication
396 * assignment algorithms.
398 public final PhylogenyNode getLink() {
403 * Returns a refernce to the next external PhylogenyNode of this
404 * PhylogenyNode. TODO should be in Phylogeny. Returns null if no next
405 * external node is available.
407 public final PhylogenyNode getNextExternalNode() {
408 if ( isInternal() ) {
409 throw new UnsupportedOperationException( "attempt to get next external node of an internal node" );
411 else if ( isLastExternalNode() ) {
414 int index = getChildNodeIndex();
415 PhylogenyNode previous_node = this;
416 PhylogenyNode current_node = getParent();
417 while ( !current_node.isRoot()
418 && ( ( current_node.getNumberOfDescendants() == 1 ) || previous_node.isLastChildNode() ) ) {
419 index = current_node.getChildNodeIndex();
420 previous_node = current_node;
421 current_node = current_node.getParent();
423 current_node = current_node.getChildNode( index + 1 );
424 while ( current_node.isInternal() ) {
425 current_node = current_node.getFirstChildNode();
430 public final PhylogenyNode getNextExternalNodeWhileTakingIntoAccountCollapsedNodes() {
432 if ( isInternal() && !isCollapse() ) {
433 throw new UnsupportedOperationException( "attempt to get next external node of an uncollapsed internal node" );
438 if ( getParent().isCollapse() ) {
439 throw new UnsupportedOperationException( "attempt to get next external node of node with a collapsed parent" );
441 // This checks if last node.
442 PhylogenyNode n = this;
444 while ( !n.isRoot() ) {
445 if ( !n.isLastChildNode() ) {
454 int index = getChildNodeIndex();
455 PhylogenyNode previous_node = this;
456 PhylogenyNode current_node = getParent();
457 while ( !current_node.isRoot()
458 && ( current_node.isCollapse() || ( current_node.getNumberOfDescendants() == 1 ) || previous_node
459 .isLastChildNode() ) ) {
460 index = current_node.getChildNodeIndex();
461 previous_node = current_node;
462 current_node = current_node.getParent();
464 if ( index < current_node.getNumberOfDescendants() - 1 ) {
465 current_node = current_node.getChildNode( index + 1 );
467 while ( current_node.isInternal() && !current_node.isCollapse() ) {
468 current_node = current_node.getFirstChildNode();
473 public final NodeData getNodeData() {
474 if ( _node_data == null ) {
475 _node_data = new NodeData();
480 final NodeData getNodeDataDirectly() {
484 // ---------------------------------------------------------
485 // Set and get methods for Nodes
486 // ---------------------------------------------------------
488 * Returns the ID (int) of this PhylogenyNode.
491 final public int getId() {
496 * Returns the name of this node.
499 final public String getName() {
500 return getNodeData().getNodeName();
503 final public List<PhylogenyNode> getAllDescendants() {
507 final public int getNumberOfDescendants() {
508 if ( _descendants == null ) {
511 return _descendants.size();
515 * Returns the total number of external Nodes originating from this
516 * PhylogenyNode (int).
518 final public int getNumberOfExternalNodes() {
519 return _sum_ext_nodes;
522 final public int getNumberOfParents() {
527 * Returns a refernce to the parent PhylogenyNode of this PhylogenyNode.
529 final public PhylogenyNode getParent() {
534 * Returns a refernce to the next external PhylogenyNode of this
535 * PhylogenyNode. TODO should be in Phylogeny. Returns null if no next
536 * external node is available.
538 final public PhylogenyNode getPreviousExternalNode() {
539 if ( isInternal() ) {
540 throw new UnsupportedOperationException( "Cannot get the previous external node for an internal node." );
542 else if ( isRoot() /* TODO && tree is rooted */) {
543 throw new UnsupportedOperationException( "Cannot get the previous external node for a root node." );
545 else if ( isFirstExternalNode() ) {
546 throw new UnsupportedOperationException( "Attempt to get previous external node of the first external node." );
548 int index = getChildNodeIndex();
549 PhylogenyNode previous_node = this;
550 PhylogenyNode current_node = getParent();
551 while ( !current_node.isRoot()
552 && ( ( current_node.getNumberOfDescendants() == 1 ) || previous_node.isFirstChildNode() ) ) {
553 index = current_node.getChildNodeIndex();
554 previous_node = current_node;
555 current_node = current_node.getParent();
557 current_node = current_node.getChildNode( index - 1 );
558 while ( current_node.isInternal() ) {
559 current_node = current_node.getLastChildNode();
565 * Used for drawing of Trees.
567 final public float getXcoord() {
571 final public float getXSecondary() {
576 * Used for drawing of Trees.
578 final public float getYcoord() {
582 final public float getYSecondary() {
587 final public int hashCode() {
588 final NodeData data = getNodeData();
589 if ( ( getName().length() < 1 ) && !data.isHasSequence() && !data.isHasTaxonomy() ) {
590 return super.hashCode();
592 int result = getName().hashCode();
593 if ( data.isHasSequence() ) {
594 result ^= data.getSequence().hashCode();
596 if ( data.isHasTaxonomy() ) {
597 result ^= data.getTaxonomy().hashCode();
602 // final private void init() {
603 //_descendants = new ArrayList<PhylogenyNode>();
604 // _parent = null; //TODO not needed?
605 // _id = 0; //TODO not needed?
606 //initializeData(); //TODO not needed?
609 * Deletes data of this PhylogenyNode. Links to the other Nodes in the
610 * Phylogeny, the ID and the sum of external nodes are NOT deleted. Field
611 * "_link" (_link to Nodes in other Phylogeny) IS deleted.
613 * @see #getLink() (Last modified: 12/20/03)
615 // final private void initializeData() {
619 // //_node_name = "";
620 // _distance_parent = PhylogenyDataUtil.BRANCH_LENGTH_DEFAULT;
621 // _collapse = false;
623 // _branch_data = null;
624 // _node_data = null;
627 * Returns whether this PhylogenyNode should be drawn as collapsed.
629 final public boolean isCollapse() {
634 * Returns true if this PhylogenyNode represents a _duplication event, false
637 final public boolean isDuplication() {
638 return getNodeData().isHasEvent() && getNodeData().getEvent().isDuplication();
642 * Checks whether this PhylogenyNode is external (tip).
644 * @return true if this PhylogenyNode is external, false otherwise
646 final public boolean isExternal() {
647 if ( _descendants == null ) {
650 return ( getNumberOfDescendants() < 1 );
656 * @return DOCUMENT ME!
658 final public boolean isFirstChildNode() {
659 if ( isRoot() /* and tree is rooted TODO */) {
660 throw new UnsupportedOperationException( "Cannot determine whether the root is the first child node of its _parent." );
662 return ( getChildNodeIndex() == 0 );
668 * @return DOCUMENT ME!
670 final public boolean isFirstExternalNode() {
671 if ( isInternal() ) {
674 PhylogenyNode node = this;
675 while ( !node.isRoot() ) {
676 if ( !node.isFirstChildNode() ) {
679 node = node.getParent();
685 * Returns whether a _duplication or speciation event has been assigned for
686 * this PhylogenyNode.
688 final public boolean isHasAssignedEvent() {
689 if ( !getNodeData().isHasEvent() ) {
692 if ( ( getNodeData().getEvent() ).isUnassigned() ) {
699 * Checks whether this PhylogenyNode is internal (tip).
701 * @return true if this PhylogenyNode is external, false otherwise
703 final public boolean isInternal() {
704 return ( !isExternal() );
708 * Returns true if this node is the last child node of its _parent.
710 * [last modified June 01, 2005 by CMZ]
712 * @return true if this node is the last child node of its _parent, false
715 final public boolean isLastChildNode() {
716 if ( isRoot() /* and tree is rooted TODO */) {
717 throw new UnsupportedOperationException( "Cannot determine whether the root is the last child node of its _parent." );
719 return ( getChildNodeIndex() == ( getParent().getNumberOfDescendants() - 1 ) );
725 * @return DOCUMENT ME!
727 final public boolean isLastExternalNode() {
728 if ( isInternal() ) {
731 PhylogenyNode node = this;
732 while ( !node.isRoot() ) {
733 if ( !node.isLastChildNode() ) {
736 node = node.getParent();
742 * Checks whether this PhylogenyNode is a root.
744 * @return true if this PhylogenyNode is the root, false otherwise
746 final public boolean isRoot() {
747 return _parent == null;
750 final public boolean isSpeciation() {
751 return getNodeData().isHasEvent() && getNodeData().getEvent().isSpeciation();
754 // ---------------------------------------------------------
756 // ---------------------------------------------------------
758 * Prints to the console the subtree originating from this PhylogenyNode in
761 public void preorderPrint() {
762 System.out.println( this + "\n" );
763 if ( isInternal() ) {
764 for( int i = 0; i < getNumberOfDescendants(); ++i ) {
765 getChildNode( i ).preorderPrint();
770 final public void removeChildNode( final int i ) {
771 if ( isExternal() ) {
772 throw new UnsupportedOperationException( "cannot get the child node for a external node." );
774 if ( ( i >= getNumberOfDescendants() ) || ( i < 0 ) ) {
775 throw new IllegalArgumentException( "attempt to get child node " + i + " of a node with "
776 + getNumberOfDescendants() + " child nodes." );
778 getDescendants().remove( i );
781 final public void removeChildNode( final PhylogenyNode remove_me ) {
782 removeChildNode( remove_me.getChildNodeIndex() );
785 final public void setBranchData( final BranchData branch_data ) {
786 _branch_data = branch_data;
790 * Sets the first child PhylogenyNode of this PhylogenyNode to n.
792 final public void setChild1( final PhylogenyNode n ) {
793 setChildNode( 0, n );
797 * Sets the second child PhylogenyNode of this PhylogenyNode to n.
799 final public void setChild2( final PhylogenyNode n ) {
800 setChildNode( 1, n );
804 * Inserts PhylogenyNode n at the specified position i into the list of
805 * child nodes. This does not allow null slots in the list of child nodes:
806 * If i is larger than the number of child nodes, n is just added to the
807 * list, not place at index i.
810 * the index of position where to add the child
812 * the PhylogenyNode to add
814 final public void setChildNode( final int i, final PhylogenyNode node ) {
815 node.setParent( this );
816 if ( getNumberOfDescendants() <= i ) {
817 addChildNode( node );
820 getDescendants().set( i, node );
824 final void setChildNodeOnly( final int i, final PhylogenyNode node ) {
825 if ( getNumberOfDescendants() <= i ) {
826 addChildNode( node );
829 getDescendants().set( i, node );
834 * Sets whether this PhylogenyNode should be drawn as collapsed.
836 final public void setCollapse( final boolean b ) {
841 * Sets the length of the branch leading to the _parent of this
842 * PhylogenyNode to double d.
845 final public void setDistanceToParent( final double d ) {
846 _distance_parent = d;
850 * Sets the _indicator value of this PhylogenyNode to i.
852 final public void setIndicator( final byte i ) {
856 // --------------------------------------------------------------------
857 // Adjust methods (related to Phylogeny construction and
858 // Phylogeny modification)
859 // --------------------------------------------------------------------
861 * Sets the indicators of all the children of this PhylogenyNode to zero.
863 final void setIndicatorsToZero() {
864 for( final PreorderTreeIterator it = new PreorderTreeIterator( this ); it.hasNext(); ) {
865 it.next().setIndicator( ( byte ) 0 );
870 * Sets the linked PhylogenyNode of this PhylogenyNode to n. Currently, this
871 * method is only used for the speciation-_duplication assignment
874 final public void setLink( final PhylogenyNode n ) {
879 * Sets the name of this node.
882 final public void setName( final String node_name ) {
883 getNodeData().setNodeName( node_name );
887 * Sets the Id of this PhylogenyNode to i. In most cases, this number
888 * should not be set to values lower than getNodeCount() -- which this method
891 synchronized final protected void setId( final int i ) {
892 if ( i < getNodeCount() ) {
893 throw new IllegalArgumentException( "attempt to set node id to a value less than total node count (thus violating the uniqueness of node ids)" );
899 * Sets the _parent PhylogenyNode of this PhylogenyNode to n.
902 final public void setParent( final PhylogenyNode n ) {
907 * Sets the total number of external Nodes originating from this
908 * PhylogenyNode to i (int).
910 final public void setSumExtNodes( final int i ) {
912 throw new IllegalArgumentException( "attempt to set sum of external nodes to less than one" );
918 * Used for drawing of Trees.
920 final public void setXcoord( final float x ) {
924 final public void setXSecondary( final float x_secondary ) {
925 _x_secondary = x_secondary;
930 * Used for drawing of Trees.
932 final public void setYcoord( final float y ) {
936 final public void setYSecondary( final float y_secondary ) {
937 _y_secondary = y_secondary;
940 // ---------------------------------------------------------
941 // Writing of Nodes to Strings
942 // ---------------------------------------------------------
943 final public String toNewHampshire( final boolean simple_nh,
944 final boolean write_distance_to_parent,
945 final NH_CONVERSION_SUPPORT_VALUE_STYLE svs ) {
946 final StringBuilder sb = new StringBuilder();
948 if ( ( svs == NH_CONVERSION_SUPPORT_VALUE_STYLE.AS_INTERNAL_NODE_NAMES ) && !isExternal() ) {
949 if ( getBranchData().isHasConfidences()
950 && ( getBranchData().getConfidence( 0 ).getValue() != Confidence.CONFIDENCE_DEFAULT_VALUE ) ) {
951 data = Confidence.FORMATTER.format( ForesterUtil
952 .round( getBranchData().getConfidence( 0 ).getValue(),
953 PhyloXmlUtil.ROUNDING_DIGITS_FOR_PHYLOXML_DOUBLE_OUTPUT ) );
956 else if ( !ForesterUtil.isEmpty( getName() ) ) {
959 else if ( getNodeData().isHasTaxonomy() ) {
960 if ( !ForesterUtil.isEmpty( getNodeData().getTaxonomy().getTaxonomyCode() ) ) {
961 data = getNodeData().getTaxonomy().getTaxonomyCode();
963 else if ( !ForesterUtil.isEmpty( getNodeData().getTaxonomy().getScientificName() ) ) {
964 data = getNodeData().getTaxonomy().getScientificName();
966 else if ( !ForesterUtil.isEmpty( getNodeData().getTaxonomy().getCommonName() ) ) {
967 data = getNodeData().getTaxonomy().getCommonName();
969 else if ( getNodeData().getTaxonomy().getTaxonomyCode() != null ) {
970 data = getNodeData().getTaxonomy().getTaxonomyCode();
973 else if ( getNodeData().isHasSequence() ) {
974 if ( !ForesterUtil.isEmpty( getNodeData().getSequence().getName() ) ) {
975 data = getNodeData().getSequence().getName();
978 if ( data.length() > 0 ) {
979 data = ForesterUtil.replaceIllegalNhCharacters( data );
980 if ( simple_nh && ( data.length() > 10 ) ) {
981 data = data.substring( 0, 11 );
983 if ( ForesterUtil.isContainsParanthesesableNhCharacter( data ) ) {
992 if ( write_distance_to_parent && ( getDistanceToParent() != PhylogenyDataUtil.BRANCH_LENGTH_DEFAULT ) ) {
994 sb.append( getDistanceToParent() );
996 if ( ( svs == NH_CONVERSION_SUPPORT_VALUE_STYLE.IN_SQUARE_BRACKETS ) && !isExternal()
997 && getBranchData().isHasConfidences()
998 && ( getBranchData().getConfidence( 0 ).getValue() != Confidence.CONFIDENCE_DEFAULT_VALUE ) ) {
1000 sb.append( Confidence.FORMATTER.format( ForesterUtil
1001 .round( getBranchData().getConfidence( 0 ).getValue(),
1002 PhyloXmlUtil.ROUNDING_DIGITS_FOR_PHYLOXML_DOUBLE_OUTPUT ) ) );
1005 return sb.toString();
1009 * Swaps the the two childern of a PhylogenyNode node of this Phylogeny.
1011 public final void swapChildren() throws RuntimeException {
1012 if ( isExternal() ) {
1013 throw new RuntimeException( "attempt to swap descendants of external node" );
1015 if ( getNumberOfDescendants() != 2 ) {
1016 throw new RuntimeException( "attempt to swap descendants of node with " + getNumberOfDescendants()
1019 final PhylogenyNode a = getChildNode( 0 );
1020 final PhylogenyNode b = getChildNode( 1 );
1021 setChildNode( 0, b );
1022 setChildNode( 1, a );
1026 * Converts this PhylogenyNode to a New Hampshire X (NHX) String
1029 final public String toNewHampshireX() {
1030 final StringBuffer sb = new StringBuffer();
1031 final StringBuffer s_nhx = new StringBuffer();
1032 if ( !ForesterUtil.isEmpty( getName() ) ) {
1033 final String name = ForesterUtil.replaceIllegalNhCharacters( getName() );
1034 if ( ForesterUtil.isContainsParanthesesableNhCharacter( name ) ) {
1043 if ( getDistanceToParent() != PhylogenyDataUtil.BRANCH_LENGTH_DEFAULT ) {
1045 sb.append( getDistanceToParent() );
1047 if ( getNodeDataDirectly() != null ) {
1048 s_nhx.append( getNodeDataDirectly().toNHX() );
1050 if ( getBranchDataDirectly() != null ) {
1051 s_nhx.append( getBranchDataDirectly().toNHX() );
1053 if ( s_nhx.length() > 0 ) {
1054 sb.append( "[&&NHX" );
1058 return sb.toString();
1062 final public String toString() {
1063 final StringBuilder sb = new StringBuilder();
1064 if ( !ForesterUtil.isEmpty( getName() ) ) {
1065 sb.append( getName() );
1068 if ( getNodeData().isHasTaxonomy() ) {
1069 if ( !ForesterUtil.isEmpty( getNodeData().getTaxonomy().getScientificName() ) ) {
1070 sb.append( getNodeData().getTaxonomy().getScientificName() );
1073 else if ( !ForesterUtil.isEmpty( getNodeData().getTaxonomy().getTaxonomyCode() ) ) {
1074 sb.append( getNodeData().getTaxonomy().getTaxonomyCode() );
1077 else if ( getNodeData().getTaxonomy().getIdentifier() != null ) {
1078 sb.append( getNodeData().getTaxonomy().getIdentifier().toString() );
1082 if ( getNodeData().isHasSequence() ) {
1083 if ( !ForesterUtil.isEmpty( getNodeData().getSequence().getName() ) ) {
1084 sb.append( getNodeData().getSequence().getName() );
1087 else if ( !ForesterUtil.isEmpty( getNodeData().getSequence().getSymbol() ) ) {
1088 sb.append( getNodeData().getSequence().getSymbol() );
1091 else if ( getNodeData().getSequence().getAccession() != null ) {
1092 sb.append( getNodeData().getTaxonomy().getIdentifier().toString() );
1096 if ( sb.length() <= 1 ) {
1098 sb.append( getId() );
1101 return sb.toString().trim();
1105 * Decreases the total number of all Nodes created so far by one.
1107 final static synchronized void decreaseNodeCount() {
1108 --PhylogenyNode._node_count;
1112 * Returns the total number of all Nodes created so far.
1114 * @return total number of Nodes (int)
1116 synchronized final public static int getNodeCount() {
1117 return PhylogenyNode._node_count;
1121 * Increases the total number of all Nodes created so far by one.
1123 synchronized final private static void increaseNodeCount() {
1124 ++PhylogenyNode._node_count;
1128 * Sets the total number of all Nodes created so far to i (int).
1130 synchronized final static void setNodeCount( final int i ) {
1131 PhylogenyNode._node_count = i;
1134 public static PhylogenyNode createInstanceFromNhxString( final String nhx ) throws NHXFormatException,
1135 PhyloXmlDataFormatException {
1136 return new PhylogenyNode( nhx, PhylogenyMethods.TAXONOMY_EXTRACTION.NO, false );
1139 public static PhylogenyNode createInstanceFromNhxString( final String nhx,
1140 final PhylogenyMethods.TAXONOMY_EXTRACTION taxonomy_extraction )
1141 throws NHXFormatException, PhyloXmlDataFormatException {
1142 return new PhylogenyNode( nhx, taxonomy_extraction, false );
1145 public static PhylogenyNode createInstanceFromNhxString( final String nhx,
1146 final PhylogenyMethods.TAXONOMY_EXTRACTION taxonomy_extraction,
1147 final boolean replace_underscores )
1148 throws NHXFormatException, PhyloXmlDataFormatException {
1149 return new PhylogenyNode( nhx, taxonomy_extraction, replace_underscores );
1152 private PhylogenyNode( final String nhx,
1153 final PhylogenyMethods.TAXONOMY_EXTRACTION taxonomy_extraction,
1154 final boolean replace_underscores ) throws NHXFormatException, PhyloXmlDataFormatException {
1156 NHXParser.parseNHX( nhx, this, taxonomy_extraction, replace_underscores );
1157 setId( PhylogenyNode.getNodeCount() );
1158 PhylogenyNode.increaseNodeCount();
1159 setSumExtNodes( 1 ); // For ext node, this number is 1 (not 0!!)