treejuxtaposer.java

生物物种进化历程的演示

 	ATD.setKey(treeDrawers.size());
	ATD.setLineThickness(linethickness);
	treeDrawers.add(ATD);
	ATD.setExpandLeaves(1, false);
//	ATD.setDimColors(true);
//	ATD.drawDirection = getLeftRight();
	return ATD;
    }

	/**
	  * Delete a tree from "trees", clean up all the data structures
	 * constructed for tree comparisons.
	 *
	 * @author  
	 * @see AccordionDrawer.AccordionDrawer.close
	 * @see AccordionDrawer.AccordionTreeDrawer.close
	 * @see AccordionDrawer.GridCell.close
	 * @see AccordionDrawer.Tree.close
	 * @see AccordionDrawer.TreeEdge.close
	 * @see AccordionDrawer.TreeNode.close
	 * @see Parse.Newick.close
	 * @see Tree2Tree.close
	 * @see TreePairs.removeTree
	 */
	public void deleteTrees(int[] treeNums) {
   
		System.out.println("VM memory before operation: "+Runtime.getRuntime().freeMemory()) ;
		System.out.println("Total memory before operation: "+Runtime.getRuntime().totalMemory()) ;
 
		for (int i = treeNums.length-1; i >= 0; i--)
		{
			Tree currTree = (Tree)trees.get(treeNums[i]);
			AccordionTreeDrawer atd = (AccordionTreeDrawer)treeDrawers.get(treeNums[i]);
			if (atd.tree != currTree)
			{
				System.out.println("Error: mismatched tree/drawer in delete: " + currTree + " != " + atd.tree);
				continue;
			}
			Component c = atd.getCanvas();
			TPs.removeTree(currTree);
			currTree.close();
			trees.remove(currTree);
			atd.shutdown();
			atd.cvsDispose();
			treeDrawers.remove(atd);
			drawPanel.remove(c);
			treeCount--;
		}
		drawPanel.validate();
	}
	
	public void postDeleteTrees()
	{
	  
	  addLeaves();
//	  clearGroup(diffGroup);
	  for (int i=0; i<groups.size(); i++)
	  	clearGroup(i); 
      
	  for (int i = 0; i < treeDrawers.size(); i++)
	  {
	  	AccordionTreeDrawerFinal atdA = (AccordionTreeDrawerFinal)treeDrawers.get(i);
	  	for (int j = i+1; j < treeDrawers.size(); j++)
	  	{
	  		AccordionTreeDrawerFinal atdB = (AccordionTreeDrawerFinal)treeDrawers.get(j);
	  		doStructuralDiff(atdA, atdB, diffGroup);
	  		doStructuralDiff(atdB, atdA, diffGroup);
	  	}
	  }
		System.gc();
		System.out.println("VM memory after operation: "+Runtime.getRuntime().freeMemory()) ;
		System.out.println("Total memory after operation: "+Runtime.getRuntime().totalMemory()) ;       
		changedMarks();
		updateTitle();
		requestRedrawAll();
	}

    /**
     * Fetch a tree by its name.  This is done by linear search as we
     * do not expect to have many trees in memory.
     *
     * @author Li Zhang
     */
    public Tree getTreeByName(String name) {
	
	for(int i=0; i<trees.size(); i++) {
	    Tree t = (Tree)trees.get(i);
	    if(t.getName().equals(name)) return t;
	}
	return null;	
    }
	

    protected void addAction(){
    	ui.addAction();
    }
//	private void quitAction()
    protected void quitAction()
	{
		// add other actions if needed when the quit menu option is selected
		//System.exit(0);
		ui.quitAction();
	}

    public void changedMarks() {
    	Iterator tdIter = treeDrawers.iterator();
	while (tdIter.hasNext()) {
	    AccordionTreeDrawer atd = (AccordionTreeDrawer)tdIter.next();
	    atd.changedMarks();
	    //System.out.println("changedmarks, cache: "+atd.cacherange);
	}
    }
	
    public void requestRedrawAll() {

    	Iterator tdIter = treeDrawers.iterator();
	while (tdIter.hasNext()) {
	    AccordionTreeDrawer atd = (AccordionTreeDrawer)tdIter.next();
	    atd.requestRedraw();
	}

    }


    // resets the leaves and recreates the node hash set and search array
    public void addLeaves()
    {
    	// hash set has constant time verification that a similarly named node has already been added
    	// a tree set is also capable of doing this job, but requires rebalancing
    	HashSet hn;
    	if (trees.size() > 0)
    		hn = new HashSet(((Tree)trees.get(0)).nodes.size() * 2);
    	else
    		hn = new HashSet();
    	int i;
    	int floatNum = 0;
    	for(i=0; i<trees.size(); i++) {
    		Tree t = (Tree)trees.get(i);
    		for(int j=0; j<t.nodes.size(); j++) {
    			String n = ((TreeNode)t.nodes.get(j)).getName();
    			if(n.length()>0)
    				hn.add(n);
    		}
    	}
    	i=0;
    	String s[] = new String[hn.size()];
    	Iterator it = hn.iterator();
    	while (it.hasNext()) {
    		s[i] = (String) it.next();
    		i++;
    	}
    	Arrays.sort(s); // one sort instead of making s a treeset which would sort with every add
    	searchFrame.initializeList(new ArrayList(Arrays.asList(s)));
	}

    public int addGroup(boolean thisTreeOnly) {
	int groupCount = groups.size();
	RangeList g = new RangeList(groupCount);
	g.setEnabled(true);
	g.setThisTreeOnly(thisTreeOnly);
	System.out.println("adding group " + groupCount);
	groups.add(g);
	groupsByIndex.add(g); // permanent ordering
	return groupCount;
    }

    public void setGroupPriority(int group) {
//    System.out.println("priority change, group " + group + " " + foundGroup);
	Object g = groupsByIndex.get(group);
	if (group <= markGroup.length) {
	    groups.remove(g);
	    groups.add(1,g); // put it first of changeable ones
	    // update keys/alpha for marked colors
	    Iterator iter = groups.listIterator(1);
	    int currKey = 0;
	    while (currKey < markGroup.length)
	    {
	    	RangeList currGroup = (RangeList)iter.next();
//			System.out.println("setting group " + currGroup.getColor().getAlpha() + " " + currGroup.hashCode() + " to key " + currKey);
	    	currGroup.setKey(currKey++);
	    }
	}
    }

	
	public void clearDrawers()
	{
		Iterator atdIter = treeDrawers.iterator();
		if( treeDrawers.size() > 1)
		while( atdIter.hasNext())
		{
			AccordionTreeDrawerFinal a = (AccordionTreeDrawerFinal) atdIter.next();
			
			if( a.baseBox != null && a == a.getBaseBox().getDrawer())
			{
			if( a.getFlashBox() != null )
				a.getFlashBox().undraw();
			a.baseBox = null;
			a.setFlashBox(null);
			a.requestRedraw(); // too much drawing
			a.actionmodeReset();
			}		
		}
	}

    // deliberately don't have removeGroup method. if you don't want
    // it anymore, disable it. why? we want the index in the groups
    // vector to match the key in the rangelist. maybe there's a less
    // hardline way to do this?...

    // what sort of error checking should we do here if group is out
    // of bounds? be silent, return null where appropriate? print out
    // error message? throw an informative exception? ...

    public void setGroupColor(int group, Color c) {
	((RangeList)groupsByIndex.get(group)).setColor(c);
    }
	
    public void setGroupEnable(int group, boolean on) {
	((RangeList)groupsByIndex.get(group)).setEnabled(on);
    }

    private void ascendTreeMark(AccordionTreeDrawer atd, AccordionTreeDrawer currTree, 
            TreeNode directlyMarked, TreeNode n, RangeList addToGroup)
    {
        // ascend currTree (from n, the bcn of directlymarked, to the root) until no more marking needs to be done
        TreeNode currIndirectNode = n.parent;
//        System.out.print(0);
        if (currIndirectNode == null) return;
//        System.out.print(1);
        TreeNode currDirectNode = TPs.getBestCorrNode(currTree.tree, currIndirectNode, atd.tree, edgeweightLevelUsed);
        if (currDirectNode == null) {return;}
//        System.out.print(2);
//      System.out.println("addedAlready: " + currChild.key + " " + currTree.getKey());
      boolean addedAlready = addToGroup.isThisRangeInList(currIndirectNode.key, currIndirectNode.key, currTree);
//      System.out.println("fitsIntoDirect: " + currDirectNode.key + " " + atd.getKey());
      boolean fitsIntoDirect = addToGroup.isThisRangeInList(currDirectNode.key, currDirectNode.key, atd);
//      System.out.println("added: " + addedAlready + "   fits: " + fitsIntoDirect);
      while (!addedAlready && fitsIntoDirect)
//        while (!addToGroup.isThisRangeInList(currIndirectNode.key, currIndirectNode.key, currTree) &&
//                currDirectNode == directlyMarked)
        {
//          System.out.print('.');
            //System.out.println("ascend mark for " + currIndirectNode);
            addToGroup.addRange(currIndirectNode.key, currIndirectNode.key, currTree);
            currIndirectNode = n.parent;
            if (currIndirectNode == null)
                break;
            currDirectNode = TPs.getBestCorrNode(atd.tree, currIndirectNode, currTree.tree, edgeweightLevelUsed);
            if (currDirectNode == null)
                break;
            
            addedAlready = addToGroup.isThisRangeInList(currIndirectNode.key, currIndirectNode.key, currTree);
            fitsIntoDirect = addToGroup.isThisRangeInList(currDirectNode.key, currDirectNode.key, atd);
        }
//      System.out.println(3);
    }
    
    private void descendTreeMark(AccordionTreeDrawer atd, AccordionTreeDrawer currTree,
            TreeNode directlyMarked, TreeNode n, RangeList addToGroup)
    {
        // descend currTree (from n to leaves recursively), until no more marking is needed
        for (int i = 0; i < n.numberChildren(); i++)
        {
            TreeNode currChild = n.getChild(i);
//            System.out.println("child " + i + " checking for descent: " + currChild);
            TreeNode currDirectNode = TPs.getBestCorrNode(currTree.tree, currChild, atd.tree, edgeweightLevelUsed);
            if (currDirectNode == null) {continue;}
//            System.out.println("addedAlready: " + currChild.key + " " + currTree.getKey());
            boolean addedAlready = addToGroup.isThisRangeInList(currChild.key, currChild.key, currTree);
//            System.out.println("fitsIntoDirect: " + currDirectNode.key + " " + atd.getKey());
            boolean fitsIntoDirect = addToGroup.isThisRangeInList(currDirectNode.key, currDirectNode.key, atd);
//            System.out.println("added: " + addedAlready + "   fits: " + fitsIntoDirect);
            if (!addedAlready && fitsIntoDirect)
            {
//                System.out.println("adding on descent: " + currChild);
                addToGroup.addRange(currChild.key, currChild.key, currTree);
                descendTreeMark(atd, currTree, directlyMarked, currChild, addToGroup);
            }
        }
//        System.out.println("d" + n.numberChildren() + " " + n.key + " RangeList: " + addToGroup);
    }
    
    // add nodes indirectly marked in all trees
    public void addNodesToGroup(int min, int max, int group, AccordionTreeDrawer atd) {
    	RangeList addToGroup = (RangeList)groupsByIndex.get(group); 
    	
		addToGroup.addRange(min, max, atd);
	//System.out.println("range now has " + ((RangeList)groupsByIndex.get(group)).ranges.size() + " elements");
	//System.out.println("added min " + min + " max " + max + " group " + group + " tree " + atd.getKey());
		// must add the nodes from all other trees as well
		Iterator iter = treeDrawers.iterator();
//		System.out.println("RangeList: " + addToGroup);
		while (iter.hasNext())
		{
			AccordionTreeDrawer currTree = (AccordionTreeDrawer)iter.next();
			if (currTree != atd) // ignore the directly marked tree
			{
				for (int i = min; i <= max; i++) // over all directly marked nodes
				{
//				    System.out.println(i + "RangeList: " + addToGroup);
				    TreeNode directlyMarked = atd.getNodeByKey(i);
					TreeNode n = TPs.getBestCorrNode(atd.tree, directlyMarked, currTree.tree, edgeweightLevelUsed);
					if (n != null)
					{
						// the key represents the current subtree selected; all children of the bcn of this subtree are added to the range
						// the subtree selected also needs to be walked to make sure all potential forest created with bcn's is handled
					    if (!addToGroup.isThisRangeInList(n.key, n.key, currTree))
					    {
//					        System.out.println("adding, checking on ascend/descend: " + n);
					        addToGroup.addRange(n.key, n.key, currTree);
							// after getting the corresponding node, search up the tree until nothing is needed to be marked
							ascendTreeMark(atd, currTree, directlyMarked, n, addToGroup);
							// also descend the tree until all nodes are marked that need to be
							descendTreeMark(atd, currTree, directlyMarked, n, addToGroup);

					        if(!stateFrame.LCAMark.isSelected())
					            addToGroup.addRange(n.key, n.key, currTree);
					        else
					            addToGroup.addRange(n.key, n.getMax(), currTree);
					    }
					}
				}
			}
		}
    }

    public void removeNodesFromGroup(int min, int max, int group, AccordionTreeDrawer atd) { 
	((RangeList)groupsByIndex.get(group)).removeRange(min, max, atd);
    }

    public Color getGroupColor(int group) { 
	return ((RangeList)groupsByIndex.get(group)).getColor();
    }

    public void clearGroup(int group) {
    	RangeList groupList = (RangeList)groupsByIndex.get(group);     	
	    groupList.clear();
//	    groupList.setColorTree(null);
	
    }

    public void unmarkGroup(int group) {
    // lcaNode.removeAll(lcaNode);
	RangeList groupList = (RangeList)groupsByIndex.get(group); 
	RangeInTree rit;
		if(groupList.getNumRanges() != 0)
		{
			rit = groupList.getFirst();
			for (int i=0; i<lcaNode.size(); i++)
			{
				if(((TreeNode)lcaNode.get(i)).getKey() == rit.getMin() )
				{
//					System.out.println("lca node key: " + rit.getMin());
				   lcaNode.remove(i);			
				}
			    }
		    }
    if(stateFrame.LCAMark.isSelected())
      this.doLCAGeom(lcaGroup, (AccordionTreeDrawer)treeDrawers.get(0));
	changedMarks();
	clearGroup(group);
    }

    RangeList getGroup(int group) { 
	return ((RangeList)groupsByIndex.get(group));
    }

	void seedGroups(AccordionTreeDrawerFinal atd)
	{
		Iterator GroupIter = groups.iterator();
		while (GroupIter.hasNext()) {
			RangeList group = (RangeList)((RangeList)GroupIter.next()).onlyThisAD(atd);
			if (true == group.getEnabled()) {
			Iterator RangeIter = group.getRanges().iterator();
			int count=0;
			while (RangeIter.hasNext())
			{ // seed all ranges for now, add count restriction back later if necessary && count < 5) {
				RangeInTree r = (RangeInTree) RangeIter.next();
				int min = r.getMin(), max = r.getMax();
				TreeNode rootNode;
				do
				{
					rootNode = atd.getNodeByKey(min);
					atd.addToDrawQueue(rootNode);
					min = rootNode.rightmostLeaf.key+1;
				}
				while (min <= max);
				count++;
			}