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.TreeBuilder;
  24 import jalview.analysis.TreeModel;
  25 import jalview.bin.Console;
  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       Console.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     Console.info(
 145             "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(
 166               "TODO: Add the locally modified tree in Jalview as a new tree in document, leaving locked tree unchanged.");
 167     }
 168   }
 169
 170   /*
 171    * (non-Javadoc)
 172    *
 173    * @see jalview.io.vamsas.DatastoreItem#updateFromDoc()
 174    */
 175   @Override
 176   public void updateFromDoc()
 177   {
 178     // should probably just open a new tree panel in the same place as the old
 179     // one
 180     // TODO: Tree.updateFromDoc
 181     /*
 182      * TreePanel tp = (TreePanel) jvobj; // getvObj2jv(tree);
 183      *
 184      * // make a new tree Object[] idata =
 185      * recoverInputData(tree.getProvenance()); try { if (idata != null &&
 186      * idata[0] != null) { inputData = (AlignmentView) idata[0]; } ntree =
 187      * getNtree(); title = tree.getNewick(0).getTitle(); if (title == null ||
 188      * title.length() == 0) { title = tree.getTitle(); // hack!!!! } } catch
 189      * (Exception e) { Cache.warn("Problems parsing treefile '" +
 190      * tree.getNewick(0).getContent() + "'", e); }
 191      */
 192     log.debug("Update the local tree in jalview from the document.");
 193
 194     if (isModifiable(tree.getModifiable()))
 195     {
 196       // synchronize(); // update();
 197       // verify any changes.
 198       log.debug("Update tree in document from jalview.");
 199     }
 200     else
 201     {
 202       // handle conflict
 203       log.debug("Add modified jalview tree as new tree in document.");
 204     }
 205   }
 206
 207   /**
 208    * correctly creates provenance for trees calculated on an alignment by
 209    * jalview.
 210    *
 211    * @param jal
 212    * @param tp
 213    * @return
 214    */
 215   private Provenance makeTreeProvenance(AlignmentI jal, TreePanel tp)
 216   {
 217     Console.debug("Making Tree provenance for " + tp.getTitle());
 218     Provenance prov = new Provenance();
 219     prov.addEntry(new Entry());
 220     prov.getEntry(0).setAction("imported " + tp.getTitle());
 221     prov.getEntry(0).setUser(provEntry.getUser());
 222     prov.getEntry(0).setApp(provEntry.getApp());
 223     prov.getEntry(0).setDate(provEntry.getDate());
 224
 225     AlignmentView originalData = tp.getTree().getOriginalData();
 226     if (originalData != null)
 227     {
 228       Input vInput = new Input();
 229       // LATER: check to see if tree input data is contained in this alignment -
 230       // or just correctly resolve the tree's seqData to the correct alignment
 231       // in
 232       // the document.
 233       Vector alsqrefs = getjv2vObjs(findAlignmentSequences(jal,
 234               tp.getTree().getOriginalData().getSequences()));
 235       Object[] alsqs = new Object[alsqrefs.size()];
 236       alsqrefs.copyInto(alsqs);
 237       vInput.setObjRef(alsqs);
 238       // now create main provenance data
 239       prov.getEntry(0).setAction("created " + tp.getTitle());
 240       prov.getEntry(0).addInput(vInput);
 241       // jalview's special input parameter for distance matrix calculations
 242       vInput.setName("jalview:seqdist"); // TODO: settle on appropriate name.
 243       prov.getEntry(0).addParam(new Param());
 244       prov.getEntry(0).getParam(0).setName("treeType");
 245       prov.getEntry(0).getParam(0).setType("utf8");
 246       prov.getEntry(0).getParam(0)
 247               .setContent(TreeBuilder.NEIGHBOUR_JOINING);
 248       // TODO: type of tree is a general parameter
 249       int ranges[] = originalData.getVisibleContigs();
 250       // VisibleContigs are with respect to alignment coordinates. Still need
 251       // offsets
 252       int start = tp.getTree().getOriginalData().getAlignmentOrigin();
 253       for (int r = 0; r < ranges.length; r += 2)
 254       {
 255         Seg visSeg = new Seg();
 256         visSeg.setStart(1 + start + ranges[r]);
 257         visSeg.setEnd(start + ranges[r + 1]);
 258         visSeg.setInclusive(true);
 259         vInput.addSeg(visSeg);
 260       }
 261     }
 262     Console.debug("Finished Tree provenance for " + tp.getTitle());
 263     return prov;
 264   }
 265
 266   /**
 267    * look up SeqCigars in an existing alignment.
 268    *
 269    * @param jal
 270    * @param sequences
 271    * @return vector of alignment sequences in order of SeqCigar array (but
 272    *         missing unfound seqcigars)
 273    */
 274   private Vector<SequenceI> findAlignmentSequences(AlignmentI jal,
 275           SeqCigar[] sequences)
 276   {
 277     SeqCigar[] tseqs = new SeqCigar[sequences.length];
 278     System.arraycopy(sequences, 0, tseqs, 0, sequences.length);
 279     Vector<SequenceI> alsq = new Vector<>();
 280     List<SequenceI> jalsqs = jal.getSequences();
 281     synchronized (jalsqs)
 282     {
 283       for (SequenceI asq : jalsqs)
 284       {
 285         for (int t = 0; t < sequences.length; t++)
 286         {
 287           if (tseqs[t] != null && (tseqs[t].getRefSeq() == asq
 288                   || tseqs[t].getRefSeq() == asq.getDatasetSequence()))
 289           // && tseqs[t].getStart()>=asq.getStart() &&
 290           // tseqs[t].getEnd()<=asq.getEnd())
 291           {
 292             tseqs[t] = null;
 293             alsq.add(asq);
 294           }
 295         }
 296       }
 297     }
 298     if (alsq.size() < sequences.length)
 299     {
 300       Console.warn(
 301               "Not recovered all alignment sequences for given set of input sequence CIGARS");
 302     }
 303     return alsq;
 304   }
 305
 306   /**
 307    *
 308    * Update jalview newick representation with TreeNode map
 309    *
 310    * @param tp
 311    *          the treepanel that this tree is bound to.
 312    */
 313   public void UpdateSequenceTreeMap(TreePanel tp)
 314   {
 315     if (tp == null || tree == null)
 316     {
 317       return;
 318     }
 319
 320     if (tp.getTree() == null)
 321     {
 322       Console.warn("Not updating SequenceTreeMap for " + tree.getVorbaId());
 323       return;
 324     }
 325     Vector<BinaryNode> leaves = tp.getTree()
 326             .findLeaves(tp.getTree().getTopNode());
 327     Treenode[] tn = tree.getTreenode(); // todo: select nodes for this
 328     // particular tree
 329     int sz = tn.length;
 330     int i = 0;
 331
 332     while (i < sz)
 333     {
 334       Treenode node = tn[i++];
 335       BinaryNode mappednode = findNodeSpec(node.getNodespec(), leaves);
 336       if (mappednode != null && mappednode instanceof SequenceNode)
 337       {
 338         SequenceNode leaf = (SequenceNode) mappednode;
 339         // check if we can make the specified association
 340         Object jvseq = null;
 341         int vrf = 0, refv = 0;
 342         while (jvseq == null && vrf < node.getVrefCount())
 343         {
 344           if (refv < node.getVref(vrf).getRefsCount())
 345           {
 346             Object noderef = node.getVref(vrf).getRefs(refv++);
 347             if (noderef instanceof AlignmentSequence)
 348             {
 349               // we only make these kind of associations
 350               jvseq = getvObj2jv((Vobject) noderef);
 351             }
 352           }
 353           else
 354           {
 355             refv = 0;
 356             vrf++;
 357           }
 358         }
 359         if (jvseq instanceof SequenceI)
 360         {
 361           leaf.setElement((SequenceI) jvseq);
 362           leaf.setPlaceholder(false);
 363         }
 364         else
 365         {
 366           leaf.setPlaceholder(true);
 367           leaf.setElement(
 368                   new Sequence(leaf.getName(), "THISISAPLACEHLDER"));
 369         }
 370       }
 371     }
 372   }
 373
 374   // / TODO: refactor to vamsas :start
 375   /**
 376    * construct treenode mappings for mapped sequences
 377    *
 378    * @param treeModel
 379    * @param newick
 380    * @return
 381    */
 382   public Treenode[] makeTreeNodes(TreeModel treeModel, Newick newick)
 383   {
 384     Vector<BinaryNode> leaves = treeModel
 385             .findLeaves(treeModel.getTopNode());
 386     Vector tnv = new Vector();
 387     Enumeration l = leaves.elements();
 388     Hashtable nodespecs = new Hashtable();
 389     while (l.hasMoreElements())
 390     {
 391       jalview.datamodel.BinaryNode tnode = (jalview.datamodel.BinaryNode) l
 392               .nextElement();
 393       if (tnode instanceof jalview.datamodel.SequenceNode)
 394       {
 395         if (!((jalview.datamodel.SequenceNode) tnode).isPlaceholder())
 396         {
 397           Object assocseq = ((BinaryNode) tnode).element();
 398           if (assocseq instanceof SequenceI)
 399           {
 400             Vobject vobj = this.getjv2vObj(assocseq);
 401             if (vobj != null)
 402             {
 403               Treenode node = new Treenode();
 404               if (newick.isRegisterable())
 405               {
 406                 this.cdoc.registerObject(newick);
 407                 node.addTreeId(newick);
 408               }
 409               node.setNodespec(makeNodeSpec(nodespecs, tnode));
 410               node.setName(tnode.getName());
 411               Vref vr = new Vref();
 412               vr.addRefs(vobj);
 413               node.addVref(vr);
 414               tnv.addElement(node);
 415             }
 416             else
 417             {
 418               jalview.bin.Console.errPrintln("WARNING: Unassociated treeNode "
 419                       + tnode.element().toString() + " "
 420                       + ((tnode.getName() != null)
 421                               ? " label " + tnode.getName()
 422                               : ""));
 423             }
 424           }
 425         }
 426       }
 427     }
 428     if (tnv.size() > 0)
 429     {
 430       Treenode[] tn = new Treenode[tnv.size()];
 431       tnv.copyInto(tn);
 432       return tn;
 433     }
 434     return new Treenode[] {};
 435   }
 436
 437   private String makeNodeSpec(Hashtable nodespecs,
 438           jalview.datamodel.BinaryNode tnode)
 439   {
 440     String nname = new String(tnode.getName());
 441     Integer nindx = (Integer) nodespecs.get(nname);
 442     if (nindx == null)
 443     {
 444       nindx = Integer.valueOf(1);
 445     }
 446     nname = nindx.toString() + " " + nname;
 447     return nname;
 448   }
 449
 450   /**
 451    * call to match up Treenode specs to NJTree parsed from document object.
 452    *
 453    * @param nodespec
 454    * @param leaves
 455    *          as returned from NJTree.findLeaves( .., ..) ..
 456    * @return
 457    */
 458   private jalview.datamodel.BinaryNode findNodeSpec(String nodespec,
 459           Vector leaves)
 460   {
 461     int occurence = -1;
 462     String nspec = nodespec.substring(nodespec.indexOf(' ') + 1);
 463     String oval = nodespec.substring(0, nodespec.indexOf(' '));
 464     try
 465     {
 466       occurence = Integer.valueOf(oval).intValue();
 467     } catch (Exception e)
 468     {
 469       jalview.bin.Console.errPrintln("Invalid nodespec '" + nodespec + "'");
 470       return null;
 471     }
 472     jalview.datamodel.BinaryNode bn = null;
 473
 474     int nocc = 0;
 475     Enumeration en = leaves.elements();
 476     while (en.hasMoreElements() && nocc < occurence)
 477     {
 478       bn = (jalview.datamodel.BinaryNode) en.nextElement();
 479       if (bn instanceof jalview.datamodel.SequenceNode
 480               && bn.getName().equals(nspec))
 481       {
 482         --occurence;
 483       }
 484       else
 485       {
 486         bn = null;
 487       }
 488     }
 489     return bn;
 490   }
 491
 492   // todo: end refactor to vamsas library
 493   /**
 494    * add jalview object to vamsas document
 495    *
 496    */
 497   @Override
 498   public void addToDocument()
 499   {
 500     tree = new uk.ac.vamsas.objects.core.Tree();
 501     bindjvvobj(tp, tree);
 502     tree.setTitle(tp.getTitle());
 503     Newick newick = new Newick();
 504     newick.setContent(tp.getTree().print());
 505     newick.setTitle(tp.getTitle());
 506     tree.addNewick(newick);
 507     tree.setProvenance(makeTreeProvenance(jal, tp));
 508     tree.setTreenode(makeTreeNodes(tp.getTree(), newick));
 509
 510     alignment.addTree(tree);
 511   }
 512
 513   /**
 514    * note: this function assumes that all sequence and alignment objects
 515    * referenced in input data has already been associated with jalview objects.
 516    *
 517    * @param tp
 518    * @param alignFrame
 519    * @return Object[] { AlignmentView, AlignmentI - reference alignment for
 520    *         input }
 521    */
 522   public Object[] recoverInputData(Provenance tp)
 523   {
 524     AlignmentViewport javport = null;
 525     jalview.datamodel.AlignmentI jal = null;
 526     jalview.datamodel.CigarArray view = null;
 527     for (int pe = 0; pe < tp.getEntryCount(); pe++)
 528     {
 529       if (tp.getEntry(pe).getInputCount() > 0)
 530       {
 531         if (tp.getEntry(pe).getInputCount() > 1)
 532         {
 533           Console.warn("Ignoring additional input spec in provenance entry "
 534                   + tp.getEntry(pe).toString());
 535         }
 536         // LATER: deal sensibly with multiple inputs
 537         Input vInput = tp.getEntry(pe).getInput(0);
 538         // is this the whole alignment or a specific set of sequences ?
 539         if (vInput.getObjRefCount() == 0)
 540         {
 541           if (tree.getV_parent() != null && tree
 542                   .getV_parent() instanceof uk.ac.vamsas.objects.core.Alignment)
 543           {
 544             javport = getViewport(tree.getV_parent());
 545             jal = javport.getAlignment();
 546             view = javport.getAlignment().getCompactAlignment();
 547           }
 548         }
 549         else
 550         {
 551           // Explicit reference - to alignment, sequences or what.
 552           if (vInput.getObjRefCount() == 1 && vInput.getObjRef(
 553                   0) instanceof uk.ac.vamsas.objects.core.Alignment)
 554           {
 555             // recover an AlignmentView for the input data
 556             javport = getViewport((Vobject) vInput.getObjRef(0));
 557             jal = javport.getAlignment();
 558             view = javport.getAlignment().getCompactAlignment();
 559           }
 560           else if (vInput.getObjRef(
 561                   0) instanceof uk.ac.vamsas.objects.core.AlignmentSequence)
 562           {
 563             // recover an AlignmentView for the input data
 564             javport = getViewport(
 565                     ((Vobject) vInput.getObjRef(0)).getV_parent());
 566             jal = javport.getAlignment();
 567             jalview.datamodel.SequenceI[] seqs = new jalview.datamodel.SequenceI[vInput
 568                     .getObjRefCount()];
 569             for (int i = 0, iSize = vInput.getObjRefCount(); i < iSize; i++)
 570             {
 571               SequenceI seq = (SequenceI) getvObj2jv(
 572                       (Vobject) vInput.getObjRef(i));
 573               seqs[i] = seq;
 574             }
 575             view = new jalview.datamodel.Alignment(seqs)
 576                     .getCompactAlignment();
 577
 578           }
 579         }
 580         int from = 1, to = jal.getWidth();
 581         int offset = 0; // deleteRange modifies its frame of reference
 582         for (int r = 0, s = vInput.getSegCount(); r < s; r++)
 583         {
 584           Seg visSeg = vInput.getSeg(r);
 585           int se[] = getSegRange(visSeg, true); // jalview doesn't do
 586           // bidirection alignments yet.
 587           if (to < se[1])
 588           {
 589             Console.warn("Ignoring invalid segment in InputData spec.");
 590           }
 591           else
 592           {
 593             if (se[0] > from)
 594             {
 595               view.deleteRange(offset + from - 1, offset + se[0] - 2);
 596               offset -= se[0] - from;
 597             }
 598             from = se[1] + 1;
 599           }
 600         }
 601         if (from < to)
 602         {
 603           view.deleteRange(offset + from - 1, offset + to - 1); // final
 604           // deletion -
 605           // TODO: check
 606           // off by
 607           // one for to
 608         }
 609         return new Object[] { new AlignmentView(view), jal };
 610       }
 611     }
 612     Console.debug(
 613             "Returning null for input data recovery from provenance.");
 614     return null;
 615   }
 616
 617   private AlignmentViewport getViewport(Vobject v_parent)
 618   {
 619     if (v_parent instanceof uk.ac.vamsas.objects.core.Alignment)
 620     {
 621       return datastore
 622               .findViewport((uk.ac.vamsas.objects.core.Alignment) v_parent);
 623     }
 624     return null;
 625   }
 626
 627   public NewickFile getNewickTree()
 628   {
 629     return ntree;
 630   }
 631
 632   public String getTitle()
 633   {
 634     return title;
 635   }
 636
 637   public AlignmentView getInputData()
 638   {
 639     return inputData;
 640   }
 641
 642   public boolean isValidTree()
 643   {
 644     try
 645     {
 646       if (ntree == null)
 647       {
 648         return false;
 649       }
 650       ntree.parse();
 651       if (ntree.getTree() != null)
 652       {
 653         ntree = getNtree();
 654       }
 655       return true;
 656     } catch (Exception e)
 657     {
 658       Console.debug("Failed to parse newick tree string", e);
 659     }
 660     return false;
 661   }
 662 }