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