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