src/jalview/io/vamsas/Tree.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.4)
   3  * Copyright (C) 2008 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18  */
  19 package jalview.io.vamsas;
  20
  21 import java.io.IOException;
  22 import java.util.Enumeration;
  23 import java.util.Hashtable;
  24 import java.util.Vector;
  25
  26 import jalview.analysis.NJTree;
  27 import jalview.analysis.SequenceIdMatcher;
  28 import jalview.bin.Cache;
  29 import jalview.datamodel.AlignmentI;
  30 import jalview.datamodel.AlignmentView;
  31 import jalview.datamodel.BinaryNode;
  32 import jalview.datamodel.SeqCigar;
  33 import jalview.datamodel.Sequence;
  34 import jalview.datamodel.SequenceI;
  35 import jalview.datamodel.SequenceNode;
  36 import jalview.gui.AlignFrame;
  37 import jalview.gui.AlignViewport;
  38 import jalview.gui.TreePanel;
  39 import jalview.io.NewickFile;
  40 import jalview.io.VamsasAppDatastore;
  41 import uk.ac.vamsas.client.Vobject;
  42 import uk.ac.vamsas.objects.core.AlignmentSequence;
  43 import uk.ac.vamsas.objects.core.Entry;
  44 import uk.ac.vamsas.objects.core.Input;
  45 import uk.ac.vamsas.objects.core.Newick;
  46 import uk.ac.vamsas.objects.core.Param;
  47 import uk.ac.vamsas.objects.core.Provenance;
  48 import uk.ac.vamsas.objects.core.Seg;
  49 import uk.ac.vamsas.objects.core.Treenode;
  50 import uk.ac.vamsas.objects.core.Vref;
  51
  52 public class Tree extends DatastoreItem
  53 {
  54   AlignmentI jal;
  55
  56   TreePanel tp;
  57
  58   uk.ac.vamsas.objects.core.Tree tree;
  59
  60   uk.ac.vamsas.objects.core.Alignment alignment; // may be null => dataset or
  61
  62   // other kind of tree
  63   private NewickFile ntree;
  64
  65   private String title;
  66
  67   private AlignmentView inputData = null;
  68
  69   public static void updateFrom(VamsasAppDatastore datastore,
  70           jalview.gui.AlignFrame alignFrame,
  71           uk.ac.vamsas.objects.core.Tree vtree)
  72   {
  73     Tree toTree = new Tree(datastore, alignFrame, vtree);
  74
  75   }
  76
  77   public Tree(VamsasAppDatastore datastore,
  78           jalview.gui.AlignFrame alignFrame,
  79           uk.ac.vamsas.objects.core.Tree vtree)
  80   {
  81     super(datastore);
  82     tree = vtree;
  83     TreePanel tp = (TreePanel) getvObj2jv(tree);
  84     if (tp != null)
  85     {
  86       if (tree.isUpdated())
  87       {
  88         Cache.log
  89                 .info("Update from vamsas document to alignment associated tree not implemented yet.");
  90       }
  91     }
  92     else
  93     {
  94       // make a new tree
  95       Object[] idata = recoverInputData(tree.getProvenance());
  96       try
  97       {
  98         if (idata != null && idata[0] != null)
  99         {
 100           inputData = (AlignmentView) idata[0];
 101         }
 102         ntree = getNtree();
 103         title = tree.getNewick(0).getTitle();
 104         if (title == null || title.length() == 0)
 105         {
 106           title = tree.getTitle(); // hack!!!!
 107         }
 108       } catch (Exception e)
 109       {
 110         Cache.log.warn("Problems parsing treefile '"
 111                 + tree.getNewick(0).getContent() + "'", e);
 112       }
 113     }
 114   }
 115
 116   private NewickFile getNtree() throws IOException
 117   {
 118     return new jalview.io.NewickFile(tree.getNewick(0).getContent());
 119   }
 120
 121   public Tree(VamsasAppDatastore datastore, TreePanel tp2, AlignmentI jal2,
 122           uk.ac.vamsas.objects.core.Alignment alignment2)
 123   {
 124     super(datastore);
 125
 126     jal = jal2;
 127     tp = tp2;
 128     alignment = alignment2;
 129
 130     tree = (uk.ac.vamsas.objects.core.Tree) getjv2vObj(tp);
 131     if (tree == null)
 132     {
 133       add();
 134     }
 135     else
 136     {
 137       if (isModifiable(tree.getModifiable()))
 138       {
 139         // synchronize(); // update();
 140         // verify any changes.
 141         System.out.println("Update tree in document.");
 142       }
 143       else
 144       {
 145         // handle conflict
 146         System.out.println("Add modified tree as new tree in document.");
 147       }
 148     }
 149   }
 150
 151   /**
 152    * correctly creates provenance for trees calculated on an alignment by
 153    * jalview.
 154    *
 155    * @param jal
 156    * @param tp
 157    * @return
 158    */
 159   private Provenance makeTreeProvenance(AlignmentI jal, TreePanel tp)
 160   {
 161     Cache.log.debug("Making Tree provenance for " + tp.getTitle());
 162     Provenance prov = new Provenance();
 163     prov.addEntry(new Entry());
 164     prov.getEntry(0).setAction("imported " + tp.getTitle());
 165     prov.getEntry(0).setUser(provEntry.getUser());
 166     prov.getEntry(0).setApp(provEntry.getApp());
 167     prov.getEntry(0).setDate(provEntry.getDate());
 168     if (tp.getTree().hasOriginalSequenceData())
 169     {
 170       Input vInput = new Input();
 171       // LATER: check to see if tree input data is contained in this alignment -
 172       // or just correctly resolve the tree's seqData to the correct alignment
 173       // in
 174       // the document.
 175       Vector alsqrefs = getjv2vObjs(findAlignmentSequences(jal, tp
 176               .getTree().seqData.getSequences()));
 177       Object[] alsqs = new Object[alsqrefs.size()];
 178       alsqrefs.copyInto(alsqs);
 179       vInput.setObjRef(alsqs);
 180       // now create main provenance data
 181       prov.getEntry(0).setAction("created " + tp.getTitle());
 182       prov.getEntry(0).addInput(vInput);
 183       // jalview's special input parameter for distance matrix calculations
 184       vInput.setName("jalview:seqdist"); // TODO: settle on appropriate name.
 185       prov.getEntry(0).addParam(new Param());
 186       prov.getEntry(0).getParam(0).setName("treeType");
 187       prov.getEntry(0).getParam(0).setType("utf8");
 188       prov.getEntry(0).getParam(0).setContent("NJ"); // TODO: type of tree is a
 189       // general parameter
 190       int ranges[] = tp.getTree().seqData.getVisibleContigs();
 191       // VisibleContigs are with respect to alignment coordinates. Still need
 192       // offsets
 193       int start = tp.getTree().seqData.getAlignmentOrigin();
 194       for (int r = 0; r < ranges.length; r += 2)
 195       {
 196         Seg visSeg = new Seg();
 197         visSeg.setStart(1 + start + ranges[r]);
 198         visSeg.setEnd(start + ranges[r + 1]);
 199         visSeg.setInclusive(true);
 200         vInput.addSeg(visSeg);
 201       }
 202     }
 203     Cache.log.debug("Finished Tree provenance for " + tp.getTitle());
 204     return prov;
 205   }
 206
 207   /**
 208    * look up SeqCigars in an existing alignment.
 209    *
 210    * @param jal
 211    * @param sequences
 212    * @return vector of alignment sequences in order of SeqCigar array (but
 213    *         missing unfound seqcigars)
 214    */
 215   private Vector findAlignmentSequences(AlignmentI jal, SeqCigar[] sequences)
 216   {
 217     SeqCigar[] tseqs = new SeqCigar[sequences.length];
 218     System.arraycopy(sequences, 0, tseqs, 0, sequences.length);
 219     Vector alsq = new Vector();
 220     Enumeration as = jal.getSequences().elements();
 221     while (as.hasMoreElements())
 222     {
 223       SequenceI asq = (SequenceI) as.nextElement();
 224       for (int t = 0; t < sequences.length; t++)
 225       {
 226         if (tseqs[t] != null
 227                 && (tseqs[t].getRefSeq() == asq || tseqs[t].getRefSeq() == asq
 228                         .getDatasetSequence()))
 229         // && tseqs[t].getStart()>=asq.getStart() &&
 230         // tseqs[t].getEnd()<=asq.getEnd())
 231         {
 232           tseqs[t] = null;
 233           alsq.add(asq);
 234         }
 235       }
 236     }
 237     if (alsq.size() < sequences.length)
 238       Cache.log
 239               .warn("Not recovered all alignment sequences for given set of input sequence CIGARS");
 240     return alsq;
 241   }
 242
 243   /**
 244    *
 245    * Update jalview newick representation with TreeNode map
 246    *
 247    * @param tp
 248    *                the treepanel that this tree is bound to.
 249    */
 250   public void UpdateSequenceTreeMap(TreePanel tp)
 251   {
 252     if (tp == null || tree == null)
 253       return;
 254     Vector leaves = new Vector();
 255     if (tp.getTree() == null)
 256     {
 257       Cache.log.warn("Not updating SequenceTreeMap for "
 258               + tree.getVorbaId());
 259       return;
 260     }
 261     tp.getTree().findLeaves(tp.getTree().getTopNode(), leaves);
 262     Treenode[] tn = tree.getTreenode(); // todo: select nodes for this
 263     // particular tree
 264     int sz = tn.length;
 265     int i = 0;
 266
 267     while (i < sz)
 268     {
 269       Treenode node = tn[i++];
 270       BinaryNode mappednode = findNodeSpec(node.getNodespec(), leaves);
 271       if (mappednode != null && mappednode instanceof SequenceNode)
 272       {
 273         SequenceNode leaf = (SequenceNode) mappednode;
 274         // check if we can make the specified association
 275         Object jvseq = null;
 276         int vrf = 0, refv = 0;
 277         while (jvseq == null && vrf < node.getVrefCount())
 278         {
 279           if (refv < node.getVref(vrf).getRefsCount())
 280           {
 281             Object noderef = node.getVref(vrf).getRefs(refv++);
 282             if (noderef instanceof AlignmentSequence)
 283             {
 284               // we only make these kind of associations
 285               jvseq = getvObj2jv((Vobject) noderef);
 286             }
 287           }
 288           else
 289           {
 290             refv = 0;
 291             vrf++;
 292           }
 293         }
 294         if (jvseq instanceof SequenceI)
 295         {
 296           leaf.setElement(jvseq);
 297           leaf.setPlaceholder(false);
 298         }
 299         else
 300         {
 301           leaf.setPlaceholder(true);
 302           leaf
 303                   .setElement(new Sequence(leaf.getName(),
 304                           "THISISAPLACEHLDER"));
 305         }
 306       }
 307     }
 308   }
 309
 310   // / TODO: refactor to vamsas :start
 311   /**
 312    * construct treenode mappings for mapped sequences
 313    *
 314    * @param ntree
 315    * @param newick
 316    * @return
 317    */
 318   public Treenode[] makeTreeNodes(NJTree ntree, Newick newick)
 319   {
 320     Vector leaves = new Vector();
 321     ntree.findLeaves(ntree.getTopNode(), leaves);
 322     Vector tnv = new Vector();
 323     Enumeration l = leaves.elements();
 324     Hashtable nodespecs = new Hashtable();
 325     while (l.hasMoreElements())
 326     {
 327       jalview.datamodel.BinaryNode tnode = (jalview.datamodel.BinaryNode) l
 328               .nextElement();
 329       if (tnode instanceof jalview.datamodel.SequenceNode)
 330       {
 331         if (!((jalview.datamodel.SequenceNode) tnode).isPlaceholder())
 332         {
 333           Object assocseq = ((jalview.datamodel.SequenceNode) tnode)
 334                   .element();
 335           if (assocseq instanceof SequenceI)
 336           {
 337             Vobject vobj = this.getjv2vObj(assocseq);
 338             if (vobj != null)
 339             {
 340               Treenode node = new Treenode();
 341               if (newick.isRegisterable())
 342               {
 343                 this.cdoc.registerObject(newick);
 344                 node.addTreeId(newick);
 345               }
 346               node.setNodespec(makeNodeSpec(nodespecs, tnode));
 347               node.setName(tnode.getName());
 348               Vref vr = new Vref();
 349               vr.addRefs(vobj);
 350               node.addVref(vr);
 351               tnv.addElement(node);
 352             }
 353             else
 354             {
 355               System.err.println("WARNING: Unassociated treeNode "
 356                       + tnode.element().toString()
 357                       + " "
 358                       + ((tnode.getName() != null) ? " label "
 359                               + tnode.getName() : ""));
 360             }
 361           }
 362         }
 363       }
 364     }
 365     if (tnv.size() > 0)
 366     {
 367       Treenode[] tn = new Treenode[tnv.size()];
 368       tnv.copyInto(tn);
 369       return tn;
 370     }
 371     return new Treenode[]
 372     {};
 373   }
 374
 375   private String makeNodeSpec(Hashtable nodespecs,
 376           jalview.datamodel.BinaryNode tnode)
 377   {
 378     String nname = new String(tnode.getName());
 379     Integer nindx = (Integer) nodespecs.get(nname);
 380     if (nindx == null)
 381     {
 382       nindx = new Integer(1);
 383     }
 384     nname = nindx.toString() + " " + nname;
 385     return nname;
 386   }
 387
 388   /**
 389    * call to match up Treenode specs to NJTree parsed from document object.
 390    *
 391    * @param nodespec
 392    * @param leaves
 393    *                as returned from NJTree.findLeaves( .., ..) ..
 394    * @return
 395    */
 396   private jalview.datamodel.BinaryNode findNodeSpec(String nodespec,
 397           Vector leaves)
 398   {
 399     int occurence = -1;
 400     String nspec = nodespec.substring(nodespec.indexOf(' ') + 1);
 401     String oval = nodespec.substring(0, nodespec.indexOf(' '));
 402     try
 403     {
 404       occurence = new Integer(oval).intValue();
 405     } catch (Exception e)
 406     {
 407       System.err.println("Invalid nodespec '" + nodespec + "'");
 408       return null;
 409     }
 410     jalview.datamodel.BinaryNode bn = null;
 411
 412     int nocc = 0;
 413     Enumeration en = leaves.elements();
 414     while (en.hasMoreElements() && nocc < occurence)
 415     {
 416       bn = (jalview.datamodel.BinaryNode) en.nextElement();
 417       if (bn instanceof jalview.datamodel.SequenceNode
 418               && bn.getName().equals(nspec))
 419       {
 420         --occurence;
 421       }
 422       else
 423         bn = null;
 424     }
 425     return bn;
 426   }
 427
 428   // todo: end refactor to vamsas library
 429   /**
 430    * add jalview object to vamsas document
 431    *
 432    */
 433   public void add()
 434   {
 435     tree = new uk.ac.vamsas.objects.core.Tree();
 436     bindjvvobj(tp, tree);
 437     tree.setTitle(tp.getTitle());
 438     Newick newick = new Newick();
 439     newick.setContent(tp.getTree().toString());
 440     newick.setTitle(tp.getTitle());
 441     tree.addNewick(newick);
 442     tree.setProvenance(makeTreeProvenance(jal, tp));
 443     tree.setTreenode(makeTreeNodes(tp.getTree(), newick));
 444
 445     alignment.addTree(tree);
 446   }
 447
 448   /**
 449    * note: this function assumes that all sequence and alignment objects
 450    * referenced in input data has already been associated with jalview objects.
 451    *
 452    * @param tp
 453    * @param alignFrame
 454    * @return Object[] { AlignmentView, AlignmentI - reference alignment for
 455    *         input }
 456    */
 457   public Object[] recoverInputData(Provenance tp)
 458   {
 459     AlignViewport javport = null;
 460     jalview.datamodel.AlignmentI jal = null;
 461     jalview.datamodel.CigarArray view = null;
 462     for (int pe = 0; pe < tp.getEntryCount(); pe++)
 463     {
 464       if (tp.getEntry(pe).getInputCount() > 0)
 465       {
 466         if (tp.getEntry(pe).getInputCount() > 1)
 467         {
 468           Cache.log
 469                   .warn("Ignoring additional input spec in provenance entry "
 470                           + tp.getEntry(pe).toString());
 471         }
 472         // LATER: deal sensibly with multiple inputs
 473         Input vInput = tp.getEntry(pe).getInput(0);
 474         // is this the whole alignment or a specific set of sequences ?
 475         if (vInput.getObjRefCount() == 0)
 476         {
 477           if (tree.getV_parent() != null
 478                   && tree.getV_parent() instanceof uk.ac.vamsas.objects.core.Alignment)
 479           {
 480             javport = getViewport(tree.getV_parent());
 481             jal = javport.getAlignment();
 482             view = javport.getAlignment().getCompactAlignment();
 483           }
 484         }
 485         else
 486         {
 487           // Explicit reference - to alignment, sequences or what.
 488           if (vInput.getObjRefCount() == 1
 489                   && vInput.getObjRef(0) instanceof uk.ac.vamsas.objects.core.Alignment)
 490           {
 491             // recover an AlignmentView for the input data
 492             javport = getViewport((Vobject) vInput.getObjRef(0));
 493             jal = javport.getAlignment();
 494             view = javport.getAlignment().getCompactAlignment();
 495           }
 496           else if (vInput.getObjRef(0) instanceof uk.ac.vamsas.objects.core.AlignmentSequence)
 497           {
 498             // recover an AlignmentView for the input data
 499             javport = getViewport(((Vobject) vInput.getObjRef(0))
 500                     .getV_parent());
 501             jal = javport.getAlignment();
 502             jalview.datamodel.SequenceI[] seqs = new jalview.datamodel.SequenceI[vInput
 503                     .getObjRefCount()];
 504             for (int i = 0, iSize = vInput.getObjRefCount(); i < iSize; i++)
 505             {
 506               SequenceI seq = (SequenceI) getvObj2jv((Vobject) vInput
 507                       .getObjRef(i));
 508               seqs[i] = seq;
 509             }
 510             view = new jalview.datamodel.Alignment(seqs)
 511                     .getCompactAlignment();
 512
 513           }
 514         }
 515         int from = 1, to = jal.getWidth();
 516         int offset = 0; // deleteRange modifies its frame of reference
 517         for (int r = 0, s = vInput.getSegCount(); r < s; r++)
 518         {
 519           Seg visSeg = vInput.getSeg(r);
 520           int se[] = getSegRange(visSeg, true); // jalview doesn't do
 521           // bidirection alignments yet.
 522           if (to < se[1])
 523           {
 524             Cache.log.warn("Ignoring invalid segment in InputData spec.");
 525           }
 526           else
 527           {
 528             if (se[0] > from)
 529             {
 530               view.deleteRange(offset + from - 1, offset + se[0] - 2);
 531               offset -= se[0] - from;
 532             }
 533             from = se[1] + 1;
 534           }
 535         }
 536         if (from < to)
 537         {
 538           view.deleteRange(offset + from - 1, offset + to - 1); // final
 539           // deletion -
 540           // TODO: check
 541           // off by
 542           // one for to
 543         }
 544         return new Object[]
 545         { new AlignmentView(view), jal };
 546       }
 547     }
 548     Cache.log
 549             .debug("Returning null for input data recovery from provenance.");
 550     return null;
 551   }
 552
 553   private AlignViewport getViewport(Vobject v_parent)
 554   {
 555     if (v_parent instanceof uk.ac.vamsas.objects.core.Alignment)
 556     {
 557       return datastore
 558               .findViewport((uk.ac.vamsas.objects.core.Alignment) v_parent);
 559     }
 560     return null;
 561   }
 562
 563   public NewickFile getNewickTree()
 564   {
 565     return ntree;
 566   }
 567
 568   public String getTitle()
 569   {
 570     return title;
 571   }
 572
 573   public AlignmentView getInputData()
 574   {
 575     return inputData;
 576   }
 577
 578   public boolean isValidTree()
 579   {
 580     try
 581     {
 582       if (ntree == null)
 583       {
 584         return false;
 585       }
 586       ntree.parse();
 587       if (ntree.getTree() != null)
 588       {
 589         ntree = getNtree();
 590       }
 591       return true;
 592     } catch (Exception e)
 593     {
 594       Cache.log.debug("Failed to parse newick tree string", e);
 595     }
 596     return false;
 597   }
 598 }