src/jalview/io/vamsas/Tree.java

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