src/jalview/io/vamsas/Tree.java

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