JAL-1632 add score model params to PCAModel and PCA constructors
[jalview.git] / src / jalview / datamodel / AlignmentView.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.datamodel;
22
23 import jalview.util.MessageManager;
24 import jalview.util.ShiftList;
25
26 import java.io.PrintStream;
27 import java.util.ArrayList;
28 import java.util.List;
29
30 /**
31  * Transient object compactly representing a 'view' of an alignment - with
32  * discontinuities marked. Extended in Jalview 2.7 to optionally record sequence
33  * groups and specific selected regions on the alignment.
34  */
35 public class AlignmentView
36 {
37   private SeqCigar[] sequences = null;
38
39   private int[] contigs = null;
40
41   private int width = 0;
42
43   private int firstCol = 0;
44
45   /**
46    * one or more ScGroup objects, which are referenced by each seqCigar's group
47    * membership
48    */
49   private List<ScGroup> scGroups = null;
50
51   private boolean isNa = false;
52
53   /**
54    * false if the view concerns peptides
55    * 
56    * @return
57    */
58   public boolean isNa()
59   {
60     return isNa;
61   }
62
63   /**
64    * Group defined over SeqCigars. Unlike AlignmentI associated groups, each
65    * SequenceGroup hold just the essential properties for the group, but no
66    * references to the sequences involved. SeqCigars hold references to the
67    * seuqenceGroup entities themselves.
68    */
69   private class ScGroup
70   {
71     public List<SeqCigar> seqs;
72
73     public SequenceGroup sg;
74
75     ScGroup()
76     {
77       seqs = new ArrayList<SeqCigar>();
78     }
79
80     /**
81      * @param seq
82      * @return true if seq was not a member before and was added to group
83      */
84     public boolean add(SeqCigar seq)
85     {
86       if (!seq.isMemberOf(this))
87       {
88         seqs.add(seq);
89         seq.setGroupMembership(this);
90         return true;
91       }
92       else
93       {
94         return false;
95       }
96     }
97
98     /**
99      * 
100      * @param seq
101      * @return true if seq was a member and was removed from group
102      */
103     public boolean remove(SeqCigar seq)
104     {
105       if (seq.removeGroupMembership(this))
106       {
107         seqs.remove(seq);
108         return true;
109       }
110       return false;
111     }
112
113     public int size()
114     {
115       return seqs.size();
116     }
117   }
118
119   /**
120    * vector of selected seqCigars. This vector is also referenced by each
121    * seqCigar contained in it.
122    */
123   private ScGroup selected;
124
125   /**
126    * Construct an alignmentView from a live jalview alignment view. Note -
127    * hidden rows will be excluded from alignmentView Note: JAL-1179
128    * 
129    * @param alignment
130    *          - alignment as referenced by an AlignViewport
131    * @param columnSelection
132    *          -
133    * @param selection
134    * @param hasHiddenColumns
135    *          - mark the hidden columns in columnSelection as hidden in the view
136    * @param selectedRegionOnly
137    *          - when set, only include the selected region in the view,
138    *          otherwise just mark the selected region on the constructed view.
139    * @param recordGroups
140    *          - when set, any groups on the given alignment will be marked on
141    *          the view
142    */
143   public AlignmentView(AlignmentI alignment,
144           ColumnSelection columnSelection, SequenceGroup selection,
145           boolean hasHiddenColumns, boolean selectedRegionOnly,
146           boolean recordGroups)
147   {
148     // refactored from AlignViewport.getAlignmentView(selectedOnly);
149     this(new jalview.datamodel.CigarArray(alignment,
150             (hasHiddenColumns ? columnSelection : null),
151             (selectedRegionOnly ? selection : null)),
152             (selectedRegionOnly && selection != null) ? selection
153                     .getStartRes() : 0);
154     isNa = alignment.isNucleotide();
155     // walk down SeqCigar array and Alignment Array - optionally restricted by
156     // selected region.
157     // test group membership for each sequence in each group, store membership
158     // and record non-empty groups in group list.
159     // record / sub-select selected region on the alignment view
160     SequenceI[] selseqs;
161     if (selection != null && selection.getSize() > 0)
162     {
163       List<SequenceI> sel = selection.getSequences(null);
164       this.selected = new ScGroup();
165       selseqs = selection
166               .getSequencesInOrder(alignment, selectedRegionOnly);
167     }
168     else
169     {
170       selseqs = alignment.getSequencesArray();
171     }
172
173     List<List<SequenceI>> seqsets = new ArrayList<List<SequenceI>>();
174     // get the alignment's group list and make a copy
175     List<SequenceGroup> grps = new ArrayList<SequenceGroup>();
176     List<SequenceGroup> gg = alignment.getGroups();
177     grps.addAll(gg);
178     ScGroup[] sgrps = null;
179     boolean addedgps[] = null;
180     if (grps != null)
181     {
182       if (selection != null && selectedRegionOnly)
183       {
184         // trim annotation to the region being stored.
185         // strip out any groups that do not actually intersect with the
186         // visible and selected region
187         int ssel = selection.getStartRes(), esel = selection.getEndRes();
188         List<SequenceGroup> isg = new ArrayList<SequenceGroup>();
189         for (SequenceGroup sg : grps)
190         {
191           if (!(sg.getStartRes() > esel || sg.getEndRes() < ssel))
192           {
193             // adjust bounds of new group, if necessary.
194             if (sg.getStartRes() < ssel)
195             {
196               sg.setStartRes(ssel);
197             }
198             if (sg.getEndRes() > esel)
199             {
200               sg.setEndRes(esel);
201             }
202             sg.setStartRes(sg.getStartRes() - ssel + 1);
203             sg.setEndRes(sg.getEndRes() - ssel + 1);
204
205             isg.add(sg);
206           }
207         }
208         grps = isg;
209       }
210
211       sgrps = new ScGroup[grps.size()];
212       addedgps = new boolean[grps.size()];
213       for (int g = 0; g < sgrps.length; g++)
214       {
215         SequenceGroup sg = grps.get(g);
216         sgrps[g] = new ScGroup();
217         sgrps[g].sg = new SequenceGroup(sg);
218         addedgps[g] = false;
219         // can't set entry 0 in an empty list
220         // seqsets.set(g, sg.getSequences(null));
221         seqsets.add(sg.getSequences());
222       }
223       // seqsets now contains vectors (should be sets) for each group, so we can
224       // track when we've done with the group
225     }
226     int csi = 0;
227     for (int i = 0; i < selseqs.length; i++)
228     {
229       if (selseqs[i] != null)
230       {
231         if (selection != null && selection.getSize() > 0
232                 && !selectedRegionOnly)
233         {
234           selected.add(sequences[csi]);
235         }
236         if (seqsets != null)
237         {
238           for (int sg = 0; sg < sgrps.length; sg++)
239           {
240             if ((seqsets.get(sg)).contains(selseqs[i]))
241             {
242               sgrps[sg].sg.deleteSequence(selseqs[i], false);
243               sgrps[sg].add(sequences[csi]);
244               if (!addedgps[sg])
245               {
246                 if (scGroups == null)
247                 {
248                   scGroups = new ArrayList<ScGroup>();
249                 }
250                 addedgps[sg] = true;
251                 scGroups.add(sgrps[sg]);
252               }
253             }
254           }
255         }
256         csi++;
257       }
258     }
259     // finally, delete the remaining sequences (if any) not selected
260     for (int sg = 0; sg < sgrps.length; sg++)
261     {
262       SequenceI[] sqs = sgrps[sg].sg.getSequencesAsArray(null);
263       for (int si = 0; si < sqs.length; si++)
264       {
265         sgrps[sg].sg.deleteSequence(sqs[si], false);
266       }
267       sgrps[sg] = null;
268     }
269   }
270
271   /**
272    * construct an alignmentView from a SeqCigarArray. Errors are thrown if the
273    * seqcigararray.isSeqCigarArray() flag is not set.
274    */
275   public AlignmentView(CigarArray seqcigararray)
276   {
277     if (!seqcigararray.isSeqCigarArray())
278     {
279       throw new Error(
280               "Implementation Error - can only make an alignment view from a CigarArray of sequences.");
281     }
282     // contigs = seqcigararray.applyDeletions();
283     contigs = seqcigararray.getDeletedRegions();
284     sequences = seqcigararray.getSeqCigarArray();
285     width = seqcigararray.getWidth(); // visible width
286   }
287
288   /**
289    * Create an alignmentView where the first column corresponds with the
290    * 'firstcol' column of some reference alignment
291    * 
292    * @param sdata
293    * @param firstcol
294    */
295   public AlignmentView(CigarArray sdata, int firstcol)
296   {
297     this(sdata);
298     firstCol = firstcol;
299   }
300
301   public void setSequences(SeqCigar[] sequences)
302   {
303     this.sequences = sequences;
304   }
305
306   public void setContigs(int[] contigs)
307   {
308     this.contigs = contigs;
309   }
310
311   public SeqCigar[] getSequences()
312   {
313     return sequences;
314   }
315
316   /**
317    * @see CigarArray.getDeletedRegions
318    * @return int[] { vis_start, sym_start, length }
319    */
320   public int[] getContigs()
321   {
322     return contigs;
323   }
324
325   /**
326    * get the full alignment and a columnselection object marking the hidden
327    * regions
328    * 
329    * @param gapCharacter
330    *          char
331    * @return Object[] { SequenceI[], ColumnSelection}
332    */
333   public Object[] getAlignmentAndColumnSelection(char gapCharacter)
334   {
335     ColumnSelection colsel = new ColumnSelection();
336
337     return new Object[] {
338         SeqCigar.createAlignmentSequences(sequences, gapCharacter, colsel,
339                 contigs), colsel };
340   }
341
342   /**
343    * return the visible alignment corresponding to this view. Sequences in this
344    * alignment are edited versions of the parent sequences - where hidden
345    * regions have been removed. NOTE: the sequence data in this alignment is not
346    * complete!
347    * 
348    * @param c
349    * @return
350    */
351   public AlignmentI getVisibleAlignment(char c)
352   {
353     SequenceI[] aln = getVisibleSeqs(c);
354
355     AlignmentI vcal = new Alignment(aln);
356     addPrunedGroupsInOrder(vcal, -1, -1, true);
357     return vcal;
358   }
359
360   /**
361    * add groups from view to the given alignment
362    * 
363    * @param vcal
364    * @param gstart
365    *          -1 or 0 to width-1
366    * @param gend
367    *          -1 or gstart to width-1
368    * @param viscontigs
369    *          - true if vcal is alignment of the visible regions of the view
370    *          (e.g. as returned from getVisibleAlignment)
371    */
372   private void addPrunedGroupsInOrder(AlignmentI vcal, int gstart,
373           int gend, boolean viscontigs)
374   {
375     boolean r = false;
376     if (gstart > -1 && gstart <= gend)
377     {
378       r = true;
379     }
380
381     SequenceI[] aln = vcal.getSequencesArray();
382     {
383       /**
384        * prune any groups to the visible coordinates of the alignment.
385        */
386       {
387         int nvg = (scGroups != null) ? scGroups.size() : 0;
388         if (nvg > 0)
389         {
390           SequenceGroup[] nsg = new SequenceGroup[nvg];
391           for (int g = 0; g < nvg; g++)
392           {
393             SequenceGroup sg = scGroups.get(g).sg;
394             if (r)
395             {
396               if (sg.getStartRes() > gend || sg.getEndRes() < gstart)
397               {
398                 // Skip this group
399                 nsg[g] = null;
400                 continue;
401               }
402             }
403
404             // clone group properties
405             nsg[g] = new SequenceGroup(sg);
406
407             // may need to shift/trim start and end ?
408             if (r && !viscontigs)
409             {
410               // Not fully tested code - routine not yet called with
411               // viscontigs==false
412               if (nsg[g].getStartRes() < gstart)
413               {
414                 nsg[g].setStartRes(0);
415               }
416               else
417               {
418                 nsg[g].setStartRes(nsg[g].getStartRes() - gstart);
419                 nsg[g].setEndRes(nsg[g].getEndRes() - gstart);
420               }
421               if (nsg[g].getEndRes() > (gend - gstart))
422               {
423                 nsg[g].setEndRes(gend - gstart);
424               }
425             }
426           }
427           if (viscontigs)
428           {
429             // prune groups to cover just the visible positions between
430             // gstart/gend.
431             if (contigs != null)
432             {
433               int p = 0;
434               ShiftList prune = new ShiftList();
435               if (r)
436               {
437                 // adjust for start of alignment within visible window.
438                 prune.addShift(gstart, -gstart); //
439               }
440               for (int h = 0; h < contigs.length; h += 3)
441               {
442                 {
443                   prune.addShift(p + contigs[h + 1], contigs[h + 2]
444                           - contigs[h + 1]);
445                 }
446                 p = contigs[h + 1] + contigs[h + 2];
447               }
448               for (int g = 0; g < nsg.length; g++)
449               {
450                 if (nsg[g] != null)
451                 {
452                   int s = nsg[g].getStartRes(), t = nsg[g].getEndRes();
453                   int w = 1 + t - s;
454                   if (r)
455                   {
456                     if (s < gstart)
457                     {
458                       s = gstart;
459                     }
460                     if (t > gend)
461                     {
462                       t = gend;
463                     }
464                   }
465                   s = prune.shift(s);
466                   t = prune.shift(t);
467                   nsg[g].setStartRes(s);
468                   nsg[g].setEndRes(t);
469                 }
470               }
471             }
472           }
473
474           for (int nsq = 0; nsq < aln.length; nsq++)
475           {
476             for (int g = 0; g < nvg; g++)
477             {
478               if (nsg[g] != null
479                       && sequences[nsq].isMemberOf(scGroups.get(g)))
480               {
481                 nsg[g].addSequence(aln[nsq], false);
482               }
483             }
484           }
485           for (int g = 0; g < nvg; g++)
486           {
487             if (nsg[g] != null && nsg[g].getSize() > 0)
488             {
489               vcal.addGroup(nsg[g]);
490             }
491             nsg[g] = null;
492           }
493         }
494       }
495     }
496   }
497
498   /**
499    * generate sequence array corresponding to the visible parts of the
500    * alignment.
501    * 
502    * @param c
503    *          gap character to use to recreate the alignment
504    * @return
505    */
506   private SequenceI[] getVisibleSeqs(char c)
507   {
508     SequenceI[] aln = new SequenceI[sequences.length];
509     for (int i = 0, j = sequences.length; i < j; i++)
510     {
511       aln[i] = sequences[i].getSeq(c);
512       // Remove hidden regions from sequence
513       aln[i].setSequence(getASequenceString(c, i));
514     }
515     return aln;
516   }
517
518   /**
519    * creates new alignment objects for all contiguous visible segments
520    * 
521    * @param c
522    * @param start
523    * @param end
524    * @param regionOfInterest
525    *          specify which sequences to include (or null to include all
526    *          sequences)
527    * @return AlignmentI[] - all alignments where each sequence is a subsequence
528    *         constructed from visible contig regions of view
529    */
530   public AlignmentI[] getVisibleContigAlignments(char c)
531   {
532     int nvc = 0;
533     int[] vcontigs = getVisibleContigs();
534     SequenceI[][] contigviews = getVisibleContigs(c);
535     AlignmentI[] vcals = new AlignmentI[contigviews.length];
536     for (nvc = 0; nvc < contigviews.length; nvc++)
537     {
538       vcals[nvc] = new Alignment(contigviews[nvc]);
539       if (scGroups != null && scGroups.size() > 0)
540       {
541         addPrunedGroupsInOrder(vcals[nvc], vcontigs[nvc * 2],
542                 vcontigs[nvc * 2 + 1], true);
543       }
544     }
545     return vcals;
546   }
547
548   /**
549    * build a string excluding hidden regions from a particular sequence in the
550    * view
551    * 
552    * @param c
553    * @param n
554    * @return
555    */
556   private String getASequenceString(char c, int n)
557   {
558     String sqn;
559     String fullseq = sequences[n].getSequenceString(c);
560     if (contigs != null)
561     {
562       sqn = "";
563       int p = 0;
564       for (int h = 0; h < contigs.length; h += 3)
565       {
566         sqn += fullseq.substring(p, contigs[h + 1]);
567         p = contigs[h + 1] + contigs[h + 2];
568       }
569       sqn += fullseq.substring(p);
570     }
571     else
572     {
573       sqn = fullseq;
574     }
575     return sqn;
576   }
577
578   /**
579    * get an array of visible sequence strings for a view on an alignment using
580    * the given gap character uses getASequenceString
581    * 
582    * @param c
583    *          char
584    * @return String[]
585    */
586   public String[] getSequenceStrings(char c)
587   {
588     String[] seqs = new String[sequences.length];
589     for (int n = 0; n < sequences.length; n++)
590     {
591       seqs[n] = getASequenceString(c, n);
592     }
593     return seqs;
594   }
595
596   /**
597    * 
598    * @return visible number of columns in alignment view
599    */
600   public int getWidth()
601   {
602     return width;
603   }
604
605   protected void setWidth(int width)
606   {
607     this.width = width;
608   }
609
610   /**
611    * get the contiguous subalignments in an alignment view.
612    * 
613    * @param gapCharacter
614    *          char
615    * @return SequenceI[][]
616    */
617   public SequenceI[][] getVisibleContigs(char gapCharacter)
618   {
619     SequenceI[][] smsa;
620     int njobs = 1;
621     if (sequences == null || width <= 0)
622     {
623       return null;
624     }
625     if (contigs != null && contigs.length > 0)
626     {
627       int start = 0;
628       njobs = 0;
629       int fwidth = width;
630       for (int contig = 0; contig < contigs.length; contig += 3)
631       {
632         if ((contigs[contig + 1] - start) > 0)
633         {
634           njobs++;
635         }
636         fwidth += contigs[contig + 2]; // end up with full region width
637         // (including hidden regions)
638         start = contigs[contig + 1] + contigs[contig + 2];
639       }
640       if (start < fwidth)
641       {
642         njobs++;
643       }
644       smsa = new SequenceI[njobs][];
645       start = 0;
646       int j = 0;
647       for (int contig = 0; contig < contigs.length; contig += 3)
648       {
649         if (contigs[contig + 1] - start > 0)
650         {
651           SequenceI mseq[] = new SequenceI[sequences.length];
652           for (int s = 0; s < mseq.length; s++)
653           {
654             mseq[s] = sequences[s].getSeq(gapCharacter).getSubSequence(
655                     start, contigs[contig + 1]);
656           }
657           smsa[j] = mseq;
658           j++;
659         }
660         start = contigs[contig + 1] + contigs[contig + 2];
661       }
662       if (start < fwidth)
663       {
664         SequenceI mseq[] = new SequenceI[sequences.length];
665         for (int s = 0; s < mseq.length; s++)
666         {
667           mseq[s] = sequences[s].getSeq(gapCharacter).getSubSequence(start,
668                   fwidth + 1);
669         }
670         smsa[j] = mseq;
671         j++;
672       }
673     }
674     else
675     {
676       smsa = new SequenceI[1][];
677       smsa[0] = new SequenceI[sequences.length];
678       for (int s = 0; s < sequences.length; s++)
679       {
680         smsa[0][s] = sequences[s].getSeq(gapCharacter);
681       }
682     }
683     return smsa;
684   }
685
686   /**
687    * return full msa and hidden regions with visible blocks replaced with new
688    * sub alignments
689    * 
690    * @param nvismsa
691    *          SequenceI[][]
692    * @param orders
693    *          AlignmentOrder[] corresponding to each SequenceI[] block.
694    * @return Object[]
695    */
696   public Object[] getUpdatedView(SequenceI[][] nvismsa,
697           AlignmentOrder[] orders, char gapCharacter)
698   {
699     if (sequences == null || width <= 0)
700     {
701       throw new Error(
702               MessageManager
703                       .getString("error.empty_view_cannot_be_updated"));
704     }
705     if (nvismsa == null)
706     {
707       throw new Error(
708               "nvismsa==null. use getAlignmentAndColumnSelection() instead.");
709     }
710     if (contigs != null && contigs.length > 0)
711     {
712       SequenceI[] alignment = new SequenceI[sequences.length];
713       ColumnSelection columnselection = new ColumnSelection();
714       if (contigs != null && contigs.length > 0)
715       {
716         int start = 0;
717         int nwidth = 0;
718         int owidth = width;
719         int j = 0;
720         for (int contig = 0; contig < contigs.length; contig += 3)
721         {
722           owidth += contigs[contig + 2]; // recover final column width
723           if (contigs[contig + 1] - start > 0)
724           {
725             int swidth = 0; // subalignment width
726             if (nvismsa[j] != null)
727             {
728               SequenceI mseq[] = nvismsa[j];
729               AlignmentOrder order = (orders == null) ? null : orders[j];
730               j++;
731               if (mseq.length != sequences.length)
732               {
733                 throw new Error(
734                         MessageManager
735                                 .formatMessage(
736                                         "error.mismatch_between_number_of_sequences_in_block",
737                                         new String[] {
738                                             Integer.valueOf(j).toString(),
739                                             Integer.valueOf(mseq.length)
740                                                     .toString(),
741                                             Integer.valueOf(
742                                                     sequences.length)
743                                                     .toString() }));
744               }
745               swidth = mseq[0].getLength(); // JBPNote: could ensure padded
746               // here.
747               for (int s = 0; s < mseq.length; s++)
748               {
749                 if (alignment[s] == null)
750                 {
751                   alignment[s] = mseq[s];
752                 }
753                 else
754                 {
755                   alignment[s].setSequence(alignment[s]
756                           .getSequenceAsString()
757                           + mseq[s].getSequenceAsString());
758                   if (mseq[s].getStart() <= mseq[s].getEnd())
759                   {
760                     alignment[s].setEnd(mseq[s].getEnd());
761                   }
762                   if (order != null)
763                   {
764                     order.updateSequence(mseq[s], alignment[s]);
765                   }
766                 }
767               }
768             }
769             else
770             {
771               // recover original alignment block or place gaps
772               if (true)
773               {
774                 // recover input data
775                 for (int s = 0; s < sequences.length; s++)
776                 {
777                   SequenceI oseq = sequences[s].getSeq(gapCharacter)
778                           .getSubSequence(start, contigs[contig + 1]);
779                   if (swidth < oseq.getLength())
780                   {
781                     swidth = oseq.getLength();
782                   }
783                   if (alignment[s] == null)
784                   {
785                     alignment[s] = oseq;
786                   }
787                   else
788                   {
789                     alignment[s].setSequence(alignment[s]
790                             .getSequenceAsString()
791                             + oseq.getSequenceAsString());
792                     if (oseq.getEnd() >= oseq.getStart())
793                     {
794                       alignment[s].setEnd(oseq.getEnd());
795                     }
796                   }
797                 }
798
799               }
800               j++;
801             }
802             nwidth += swidth;
803           }
804           // advance to begining of visible region
805           start = contigs[contig + 1] + contigs[contig + 2];
806           // add hidden segment to right of next region
807           for (int s = 0; s < sequences.length; s++)
808           {
809             SequenceI hseq = sequences[s].getSeq(gapCharacter)
810                     .getSubSequence(contigs[contig + 1], start);
811             if (alignment[s] == null)
812             {
813               alignment[s] = hseq;
814             }
815             else
816             {
817               alignment[s].setSequence(alignment[s].getSequenceAsString()
818                       + hseq.getSequenceAsString());
819               if (hseq.getEnd() >= hseq.getStart())
820               {
821                 alignment[s].setEnd(hseq.getEnd());
822               }
823             }
824           }
825           // mark hidden segment as hidden in the new alignment
826           columnselection.hideColumns(nwidth, nwidth + contigs[contig + 2]
827                   - 1);
828           nwidth += contigs[contig + 2];
829         }
830         // Do final segment - if it exists
831         if (j < nvismsa.length)
832         {
833           int swidth = 0;
834           if (nvismsa[j] != null)
835           {
836             SequenceI mseq[] = nvismsa[j];
837             AlignmentOrder order = (orders != null) ? orders[j] : null;
838             swidth = mseq[0].getLength();
839             for (int s = 0; s < mseq.length; s++)
840             {
841               if (alignment[s] == null)
842               {
843                 alignment[s] = mseq[s];
844               }
845               else
846               {
847                 alignment[s].setSequence(alignment[s].getSequenceAsString()
848                         + mseq[s].getSequenceAsString());
849                 if (mseq[s].getEnd() >= mseq[s].getStart())
850                 {
851                   alignment[s].setEnd(mseq[s].getEnd());
852                 }
853                 if (order != null)
854                 {
855                   order.updateSequence(mseq[s], alignment[s]);
856                 }
857               }
858             }
859           }
860           else
861           {
862             if (start < owidth)
863             {
864               // recover input data or place gaps
865               if (true)
866               {
867                 // recover input data
868                 for (int s = 0; s < sequences.length; s++)
869                 {
870                   SequenceI oseq = sequences[s].getSeq(gapCharacter)
871                           .getSubSequence(start, owidth + 1);
872                   if (swidth < oseq.getLength())
873                   {
874                     swidth = oseq.getLength();
875                   }
876                   if (alignment[s] == null)
877                   {
878                     alignment[s] = oseq;
879                   }
880                   else
881                   {
882                     alignment[s].setSequence(alignment[s]
883                             .getSequenceAsString()
884                             + oseq.getSequenceAsString());
885                     if (oseq.getEnd() >= oseq.getStart())
886                     {
887                       alignment[s].setEnd(oseq.getEnd());
888                     }
889                   }
890                 }
891                 nwidth += swidth;
892               }
893               else
894               {
895                 // place gaps.
896                 throw new Error(
897                         MessageManager
898                                 .getString("error.padding_not_yet_implemented"));
899               }
900             }
901           }
902         }
903       }
904       return new Object[] { alignment, columnselection };
905     }
906     else
907     {
908       if (nvismsa.length != 1)
909       {
910         throw new Error(
911                 MessageManager
912                         .formatMessage(
913                                 "error.mismatch_between_visible_blocks_to_update_and_number_of_contigs_in_view",
914                                 new String[] { Integer.valueOf(
915                                         nvismsa.length).toString() }));
916       }
917       if (nvismsa[0] != null)
918       {
919         return new Object[] { nvismsa[0], new ColumnSelection() };
920       }
921       else
922       {
923         return getAlignmentAndColumnSelection(gapCharacter);
924       }
925     }
926   }
927
928   /**
929    * returns simple array of start end positions of visible range on alignment.
930    * vis_start and vis_end are inclusive - use
931    * SequenceI.getSubSequence(vis_start, vis_end+1) to recover visible sequence
932    * from underlying alignment.
933    * 
934    * @return int[] { start_i, end_i } for 1<i<n visible regions.
935    */
936   public int[] getVisibleContigs()
937   {
938     if (contigs != null && contigs.length > 0)
939     {
940       int start = 0;
941       int nvis = 0;
942       int fwidth = width;
943       for (int contig = 0; contig < contigs.length; contig += 3)
944       {
945         if ((contigs[contig + 1] - start) > 0)
946         {
947           nvis++;
948         }
949         fwidth += contigs[contig + 2]; // end up with full region width
950         // (including hidden regions)
951         start = contigs[contig + 1] + contigs[contig + 2];
952       }
953       if (start < fwidth)
954       {
955         nvis++;
956       }
957       int viscontigs[] = new int[nvis * 2];
958       nvis = 0;
959       start = 0;
960       for (int contig = 0; contig < contigs.length; contig += 3)
961       {
962         if ((contigs[contig + 1] - start) > 0)
963         {
964           viscontigs[nvis] = start;
965           viscontigs[nvis + 1] = contigs[contig + 1] - 1; // end is inclusive
966           nvis += 2;
967         }
968         start = contigs[contig + 1] + contigs[contig + 2];
969       }
970       if (start < fwidth)
971       {
972         viscontigs[nvis] = start;
973         viscontigs[nvis + 1] = fwidth; // end is inclusive
974         nvis += 2;
975       }
976       return viscontigs;
977     }
978     else
979     {
980       return new int[] { 0, width };
981     }
982   }
983
984   /**
985    * 
986    * @return position of first visible column of AlignmentView within its
987    *         parent's alignment reference frame
988    */
989   public int getAlignmentOrigin()
990   {
991     return firstCol;
992   }
993
994   /**
995    * compute a deletion map for the current view according to the given
996    * gap/match map
997    * 
998    * @param gapMap
999    *          (as returned from SequenceI.gapMap())
1000    * @return int[] {intersection of visible regions with gapMap)
1001    */
1002   public int[] getVisibleContigMapFor(int[] gapMap)
1003   {
1004     int[] delMap = null;
1005     int[] viscontigs = getVisibleContigs();
1006     int spos = 0;
1007     int i = 0;
1008     if (viscontigs != null)
1009     {
1010       // viscontigs maps from a subset of the gapMap to the gapMap, so it will
1011       // always be equal to or shorter than gapMap
1012       delMap = new int[gapMap.length];
1013       for (int contig = 0; contig < viscontigs.length; contig += 2)
1014       {
1015
1016         while (spos < gapMap.length && gapMap[spos] < viscontigs[contig])
1017         {
1018           spos++;
1019         }
1020         while (spos < gapMap.length
1021                 && gapMap[spos] <= viscontigs[contig + 1])
1022         {
1023           delMap[i++] = spos++;
1024         }
1025       }
1026       int tmap[] = new int[i];
1027       System.arraycopy(delMap, 0, tmap, 0, i);
1028       delMap = tmap;
1029     }
1030     return delMap;
1031   }
1032
1033   /**
1034    * apply the getSeq(gc) method to each sequence cigar, and return the array of
1035    * edited sequences, optionally with hidden regions removed.
1036    * 
1037    * @param gc
1038    *          gap character to use for insertions
1039    * @param delete
1040    *          remove hidden regions from sequences. Note: currently implemented
1041    *          in a memory inefficient way - space needed is 2*result set for
1042    *          deletion
1043    * 
1044    * @return SequenceI[]
1045    */
1046   public SequenceI[] getEditedSequences(char gc, boolean delete)
1047   {
1048     SeqCigar[] msf = getSequences();
1049     SequenceI[] aln = new SequenceI[msf.length];
1050     for (int i = 0, j = msf.length; i < j; i++)
1051     {
1052       aln[i] = msf[i].getSeq(gc);
1053     }
1054     if (delete)
1055     {
1056       String[] sqs = getSequenceStrings(gc);
1057       for (int i = 0; i < sqs.length; i++)
1058       {
1059         aln[i].setSequence(sqs[i]);
1060         sqs[i] = null;
1061       }
1062     }
1063     return aln;
1064   }
1065
1066   public static void summariseAlignmentView(AlignmentView view,
1067           PrintStream os)
1068   {
1069     os.print("View has " + view.sequences.length + " of which ");
1070     if (view.selected == null)
1071     {
1072       os.print("None");
1073     }
1074     else
1075     {
1076       os.print(" " + view.selected.size());
1077     }
1078     os.println(" are selected.");
1079     os.print("View is " + view.getWidth() + " columns wide");
1080     int viswid = 0;
1081     int[] contigs = view.getContigs();
1082     if (contigs != null)
1083     {
1084       viswid = view.width;
1085       for (int i = 0; i < contigs.length; i += 3)
1086       {
1087         viswid += contigs[i + 2];
1088       }
1089       os.println("with " + viswid + " visible columns spread over "
1090               + contigs.length / 3 + " regions.");
1091     }
1092     else
1093     {
1094       viswid = view.width;
1095       os.println(".");
1096     }
1097     if (view.scGroups != null)
1098     {
1099       os.println("There are " + view.scGroups.size()
1100               + " groups defined on the view.");
1101       for (int g = 0; g < view.scGroups.size(); g++)
1102       {
1103         ScGroup sgr = view.scGroups.get(g);
1104         os.println("Group " + g + ": Name = " + sgr.sg.getName()
1105                 + " Contains " + sgr.seqs.size() + " Seqs.");
1106         os.println("This group runs from " + sgr.sg.getStartRes() + " to "
1107                 + sgr.sg.getEndRes());
1108         for (int s = 0; s < sgr.seqs.size(); s++)
1109         {
1110           // JBPnote this should be a unit test for ScGroup
1111           if (!sgr.seqs.get(s).isMemberOf(sgr))
1112           {
1113             os.println("** WARNING: sequence " + sgr.seqs.get(s).toString()
1114                     + " is not marked as member of group.");
1115           }
1116         }
1117       }
1118       AlignmentI visal = view.getVisibleAlignment('-');
1119       if (visal != null)
1120       {
1121         os.println("Vis. alignment is " + visal.getWidth()
1122                 + " wide and has " + visal.getHeight() + " seqs.");
1123         if (visal.getGroups() != null && visal.getGroups().size() > 0)
1124         {
1125
1126           int i = 1;
1127           for (SequenceGroup sg : visal.getGroups())
1128           {
1129             os.println("Group " + (i++) + " begins at column "
1130                     + sg.getStartRes() + " and ends at " + sg.getEndRes());
1131           }
1132         }
1133       }
1134     }
1135   }
1136
1137   public static void testSelectionViews(AlignmentI alignment,
1138           ColumnSelection csel, SequenceGroup selection)
1139   {
1140     System.out.println("Testing standard view creation:\n");
1141     AlignmentView view = null;
1142     try
1143     {
1144       System.out
1145               .println("View with no hidden columns, no limit to selection, no groups to be collected:");
1146       view = new AlignmentView(alignment, csel, selection, false, false,
1147               false);
1148       summariseAlignmentView(view, System.out);
1149
1150     } catch (Exception e)
1151     {
1152       e.printStackTrace();
1153       System.err
1154               .println("Failed to generate alignment with selection but no groups marked.");
1155     }
1156     try
1157     {
1158       System.out
1159               .println("View with no hidden columns, no limit to selection, and all groups to be collected:");
1160       view = new AlignmentView(alignment, csel, selection, false, false,
1161               true);
1162       summariseAlignmentView(view, System.out);
1163     } catch (Exception e)
1164     {
1165       e.printStackTrace();
1166       System.err
1167               .println("Failed to generate alignment with selection marked but no groups marked.");
1168     }
1169     try
1170     {
1171       System.out
1172               .println("View with no hidden columns, limited to selection and no groups to be collected:");
1173       view = new AlignmentView(alignment, csel, selection, false, true,
1174               false);
1175       summariseAlignmentView(view, System.out);
1176     } catch (Exception e)
1177     {
1178       e.printStackTrace();
1179       System.err
1180               .println("Failed to generate alignment with selection restricted but no groups marked.");
1181     }
1182     try
1183     {
1184       System.out
1185               .println("View with no hidden columns, limited to selection, and all groups to be collected:");
1186       view = new AlignmentView(alignment, csel, selection, false, true,
1187               true);
1188       summariseAlignmentView(view, System.out);
1189     } catch (Exception e)
1190     {
1191       e.printStackTrace();
1192       System.err
1193               .println("Failed to generate alignment with selection restricted and groups marked.");
1194     }
1195     try
1196     {
1197       System.out
1198               .println("View *with* hidden columns, no limit to selection, no groups to be collected:");
1199       view = new AlignmentView(alignment, csel, selection, true, false,
1200               false);
1201       summariseAlignmentView(view, System.out);
1202     } catch (Exception e)
1203     {
1204       e.printStackTrace();
1205       System.err
1206               .println("Failed to generate alignment with selection but no groups marked.");
1207     }
1208     try
1209     {
1210       System.out
1211               .println("View *with* hidden columns, no limit to selection, and all groups to be collected:");
1212       view = new AlignmentView(alignment, csel, selection, true, false,
1213               true);
1214       summariseAlignmentView(view, System.out);
1215     } catch (Exception e)
1216     {
1217       e.printStackTrace();
1218       System.err
1219               .println("Failed to generate alignment with selection marked but no groups marked.");
1220     }
1221     try
1222     {
1223       System.out
1224               .println("View *with* hidden columns, limited to selection and no groups to be collected:");
1225       view = new AlignmentView(alignment, csel, selection, true, true,
1226               false);
1227       summariseAlignmentView(view, System.out);
1228     } catch (Exception e)
1229     {
1230       e.printStackTrace();
1231       System.err
1232               .println("Failed to generate alignment with selection restricted but no groups marked.");
1233     }
1234     try
1235     {
1236       System.out
1237               .println("View *with* hidden columns, limited to selection, and all groups to be collected:");
1238       view = new AlignmentView(alignment, csel, selection, true, true, true);
1239       summariseAlignmentView(view, System.out);
1240     } catch (Exception e)
1241     {
1242       e.printStackTrace();
1243       System.err
1244               .println("Failed to generate alignment with selection restricted and groups marked.");
1245     }
1246
1247   }
1248 }