2 * Jalview - A Sequence Alignment Editor and Viewer (Version 2.6)
\r
3 * Copyright (C) 2010 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle
\r
5 * This file is part of Jalview.
\r
7 * Jalview is free software: you can redistribute it and/or
\r
8 * modify it under the terms of the GNU General Public License
\r
9 * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
\r
11 * Jalview is distributed in the hope that it will be useful, but
\r
12 * WITHOUT ANY WARRANTY; without even the implied warranty
\r
13 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
\r
14 * PURPOSE. See the GNU General Public License for more details.
\r
16 * You should have received a copy of the GNU General Public License along with Jalview. If not, see <http://www.gnu.org/licenses/>.
\r
18 package jalview.datamodel;
\r
20 import jalview.util.ShiftList;
\r
22 import java.io.PrintStream;
\r
23 import java.util.Enumeration;
\r
24 import java.util.Vector;
\r
27 * Transient object compactly representing a 'view' of an alignment - with
\r
28 * discontinuities marked. Extended in Jalview 2.7 to optionally record sequence
\r
29 * groups and specific selected regions on the alignment.
\r
31 public class AlignmentView
\r
33 private SeqCigar[] sequences = null;
\r
35 private int[] contigs = null;
\r
37 private int width = 0;
\r
39 private int firstCol = 0;
\r
42 * one or more ScGroup objects, which are referenced by each seqCigar's group
\r
45 private Vector scGroups;
\r
48 * Group defined over SeqCigars. Unlike AlignmentI associated groups, each
\r
49 * SequenceGroup hold just the essential properties for the group, but no
\r
50 * references to the sequences involved. SeqCigars hold references to the
\r
51 * seuqenceGroup entities themselves.
\r
53 private class ScGroup
\r
57 public SequenceGroup sg;
\r
61 seqs = new Vector();
\r
66 * vector of selected seqCigars. This vector is also referenced by each
\r
67 * seqCigar contained in it.
\r
69 private Vector selected;
\r
72 * Construct an alignmentView from a live jalview alignment view. Note -
\r
73 * hidden rows will be excluded from alignmentView
\r
76 * - alignment as referenced by an AlignViewport
\r
77 * @param columnSelection
\r
80 * @param hasHiddenColumns
\r
81 * - mark the hidden columns in columnSelection as hidden in the view
\r
82 * @param selectedRegionOnly
\r
83 * - when set, only include the selected region in the view,
\r
84 * otherwise just mark the selected region on the constructed view.
\r
85 * @param recordGroups
\r
86 * - when set, any groups on the given alignment will be marked on
\r
89 public AlignmentView(AlignmentI alignment,
\r
90 ColumnSelection columnSelection, SequenceGroup selection,
\r
91 boolean hasHiddenColumns, boolean selectedRegionOnly,
\r
92 boolean recordGroups)
\r
94 // refactored from AlignViewport.getAlignmentView(selectedOnly);
\r
95 this(new jalview.datamodel.CigarArray(alignment,
\r
96 (hasHiddenColumns ? columnSelection : null),
\r
97 (selectedRegionOnly ? selection : null)),
\r
98 (selectedRegionOnly && selection != null) ? selection
\r
99 .getStartRes() : 0);
\r
100 // walk down SeqCigar array and Alignment Array - optionally restricted by
\r
101 // selected region.
\r
102 // test group membership for each sequence in each group, store membership
\r
103 // and record non-empty groups in group list.
\r
104 // record / sub-select selected region on the alignment view
\r
105 SequenceI[] selseqs;
\r
106 if (selection != null)
\r
108 Vector sel = selection.getSequences(null);
\r
109 this.selected = new Vector();
\r
110 selseqs = selection.getSequencesInOrder(alignment, false);
\r
114 selseqs = alignment.getSequencesArray();
\r
117 // get the alignment's group list and make a copy
\r
118 Vector grps = new Vector();
\r
119 Vector gg = alignment.getGroups();
\r
120 Enumeration gge = gg.elements();
\r
121 while (gge.hasMoreElements())
\r
123 grps.addElement(gge.nextElement());
\r
125 ScGroup[] sgrps = null;
\r
126 boolean addedgps[] = null;
\r
130 if (selection != null && selectedRegionOnly)
\r
132 // trim annotation to the region being stored.
\r
133 // strip out any groups that do not actually intersect with the
\r
134 // visible and selected region
\r
135 int ssel = selection.getStartRes(), esel = selection.getEndRes();
\r
136 Vector isg = new Vector();
\r
137 Enumeration en = grps.elements();
\r
138 while (en.hasMoreElements())
\r
140 sg = (SequenceGroup) en.nextElement();
\r
142 if (!(sg.getStartRes() > esel || sg.getEndRes() < ssel))
\r
144 // adjust bounds of new group, if necessary.
\r
145 if (sg.getStartRes() < ssel)
\r
147 sg.setStartRes(ssel);
\r
149 if (sg.getEndRes() > esel)
\r
151 sg.setEndRes(esel);
\r
153 sg.setStartRes(sg.getStartRes()-ssel+1);
\r
154 sg.setEndRes(sg.getEndRes()-ssel+1);
\r
156 isg.addElement(sg);
\r
162 sgrps = new ScGroup[grps.size()];
\r
163 addedgps = new boolean[grps.size()];
\r
164 for (int g = 0; g < sgrps.length; g++)
\r
166 sg = (SequenceGroup) grps.elementAt(g);
\r
167 sgrps[g] = new ScGroup();
\r
168 sgrps[g].sg = new SequenceGroup(sg);
\r
169 addedgps[g] = false;
\r
170 grps.setElementAt(sg.getSequences(null), g);
\r
172 // grps now contains vectors (should be sets) for each group, so we can
\r
173 // track when we've done with the group
\r
176 for (int i = 0; i < selseqs.length; i++)
\r
178 if (selseqs[i] != null)
\r
180 if (selection != null && !selectedRegionOnly)
\r
182 sequences[csi].setGroupMembership(selected);
\r
183 selected.addElement(sequences[csi]);
\r
187 for (int sg = 0; sg < sgrps.length; sg++)
\r
189 if (((Vector) grps.elementAt(sg)).contains(selseqs[i]))
\r
191 sequences[csi].setGroupMembership(sgrps[sg]);
\r
192 sgrps[sg].sg.deleteSequence(selseqs[i], false);
\r
193 sgrps[sg].seqs.addElement(sequences[csi]);
\r
196 if (scGroups == null)
\r
198 scGroups = new Vector();
\r
200 addedgps[sg] = true;
\r
201 scGroups.addElement(sgrps[sg]);
\r
209 // finally, delete the remaining sequences (if any) not selected
\r
210 for (int sg = 0; sg < sgrps.length; sg++)
\r
212 SequenceI[] sqs = sgrps[sg].sg.getSequencesAsArray(null);
\r
213 for (int si = 0; si < sqs.length; si++)
\r
215 sgrps[sg].sg.deleteSequence(sqs[si], false);
\r
222 * construct an alignmentView from a SeqCigarArray. Errors are thrown if the
\r
223 * seqcigararray.isSeqCigarArray() flag is not set.
\r
225 public AlignmentView(CigarArray seqcigararray)
\r
227 if (!seqcigararray.isSeqCigarArray())
\r
230 "Implementation Error - can only make an alignment view from a CigarArray of sequences.");
\r
232 // contigs = seqcigararray.applyDeletions();
\r
233 contigs = seqcigararray.getDeletedRegions();
\r
234 sequences = seqcigararray.getSeqCigarArray();
\r
235 width = seqcigararray.getWidth(); // visible width
\r
239 * Create an alignmentView where the first column corresponds with the
\r
240 * 'firstcol' column of some reference alignment
\r
245 public AlignmentView(CigarArray sdata, int firstcol)
\r
248 firstCol = firstcol;
\r
251 public void setSequences(SeqCigar[] sequences)
\r
253 this.sequences = sequences;
\r
256 public void setContigs(int[] contigs)
\r
258 this.contigs = contigs;
\r
261 public SeqCigar[] getSequences()
\r
267 * @see CigarArray.getDeletedRegions
\r
268 * @return int[] { vis_start, sym_start, length }
\r
270 public int[] getContigs()
\r
276 * get the full alignment and a columnselection object marking the hidden
\r
279 * @param gapCharacter
\r
281 * @return Object[] { SequenceI[], ColumnSelection}
\r
283 public Object[] getAlignmentAndColumnSelection(char gapCharacter)
\r
285 ColumnSelection colsel = new ColumnSelection();
\r
287 return new Object[]
\r
289 SeqCigar.createAlignmentSequences(sequences, gapCharacter, colsel,
\r
290 contigs), colsel };
\r
294 * return the visible alignment corresponding to this view. Sequences in this
\r
295 * alignment are edited versions of the parent sequences - where hidden
\r
296 * regions have been removed. NOTE: the sequence data in this alignment is not
\r
302 public AlignmentI getVisibleAlignment(char c)
\r
304 SequenceI[] aln = getVisibleSeqs(c);
\r
306 AlignmentI vcal = new Alignment(aln);
\r
307 addPrunedGroupsInOrder(vcal, -1, -1, true);
\r
312 * add groups from view to the given alignment
\r
316 * -1 or 0 to width-1
\r
318 * -1 or gstart to width-1
\r
319 * @param viscontigs
\r
320 * - true if vcal is alignment of the visible regions of the view
\r
321 * (e.g. as returned from getVisibleAlignment)
\r
323 private void addPrunedGroupsInOrder(AlignmentI vcal, int gstart,
\r
324 int gend, boolean viscontigs)
\r
327 if (gstart > -1 && gstart <= gend)
\r
332 SequenceI[] aln = vcal.getSequencesArray();
\r
335 * prune any groups to the visible coordinates of the alignment.
\r
338 int nvg = (scGroups != null) ? scGroups.size() : 0;
\r
341 SequenceGroup[] nsg = new SequenceGroup[nvg];
\r
342 for (int g = 0; g < nvg; g++)
\r
344 SequenceGroup sg = ((ScGroup) scGroups.elementAt(g)).sg;
\r
347 if (sg.getStartRes() > gend || sg.getEndRes() < gstart)
\r
354 // may need to shift/trim start and end ?
\r
355 if (r && !viscontigs)
\r
357 if (nsg[g].getStartRes() < gstart)
\r
359 nsg[g].setStartRes(0);
\r
363 nsg[g].setStartRes(nsg[g].getStartRes() - gstart);
\r
364 nsg[g].setEndRes(nsg[g].getEndRes() - gstart);
\r
366 if (nsg[g].getEndRes() > gend)
\r
368 nsg[g].setEndRes(gend);
\r
372 // clone group properties
\r
373 nsg[g] = new SequenceGroup(sg);
\r
377 // prune groups to cover just the visible positions between
\r
379 if (contigs != null)
\r
382 ShiftList prune = new ShiftList();
\r
385 // adjust for start of alignment within visible window.
\r
386 prune.addShift(gstart, -gstart); //
\r
388 for (int h = 0; h < contigs.length; h += 3)
\r
391 prune.addShift(p + contigs[h + 1], contigs[h + 2]
\r
394 p = contigs[h + 1] + contigs[h + 2];
\r
396 for (int g = 0; g < nsg.length; g++)
\r
398 if (nsg[g] != null)
\r
400 int s = nsg[g].getStartRes(), t = nsg[g].getEndRes();
\r
413 s = prune.shift(s);
\r
414 t = prune.shift(t);
\r
415 nsg[g].setStartRes(s);
\r
416 nsg[g].setEndRes(t);
\r
422 for (int nsq = 0; nsq < aln.length; nsq++)
\r
424 for (int g = 0; g < nvg; g++)
\r
427 && sequences[nsq].isMemberOf(scGroups.elementAt(g)))
\r
429 nsg[g].addSequence(aln[nsq], false);
\r
433 for (int g = 0; g < nvg; g++)
\r
435 if (nsg[g] != null && nsg[g].getSize() > 0)
\r
437 vcal.addGroup(nsg[g]);
\r
447 * generate sequence array corresponding to the visible parts of the
\r
453 private SequenceI[] getVisibleSeqs(char c)
\r
455 SequenceI[] aln = new SequenceI[sequences.length];
\r
456 for (int i = 0, j = sequences.length; i < j; i++)
\r
458 aln[i] = sequences[i].getSeq('-');
\r
460 // Remove hidden regions from sequence objects.
\r
461 String seqs[] = getSequenceStrings('-');
\r
462 for (int i = 0, j = aln.length; i < j; i++)
\r
464 aln[i].setSequence(seqs[i]);
\r
470 * creates new alignment objects for all contiguous visible segments
\r
475 * @param regionOfInterest
\r
476 * specify which sequences to include (or null to include all
\r
478 * @return AlignmentI[] - all alignments where each sequence is a subsequence
\r
479 * constructed from visible contig regions of view
\r
481 public AlignmentI[] getVisibleContigAlignments(char c)
\r
484 int[] vcontigs = getVisibleContigs();
\r
485 SequenceI[][] contigviews = getVisibleContigs(c);
\r
486 AlignmentI[] vcals = new AlignmentI[contigviews.length];
\r
487 for (nvc = 0; nvc < contigviews.length; nvc++)
\r
489 vcals[nvc] = new Alignment(contigviews[nvc]);
\r
490 if (scGroups!=null && scGroups.size()>0)
\r
492 addPrunedGroupsInOrder(vcals[nvc], vcontigs[nvc*2],vcontigs[nvc*2+1], true);
\r
500 * get an array of visible sequence strings for a view on an alignment using
\r
501 * the given gap character
\r
507 public String[] getSequenceStrings(char c)
\r
509 String[] seqs = new String[sequences.length];
\r
510 for (int n = 0; n < sequences.length; n++)
\r
512 String fullseq = sequences[n].getSequenceString(c);
\r
513 if (contigs != null)
\r
517 for (int h = 0; h < contigs.length; h += 3)
\r
519 seqs[n] += fullseq.substring(p, contigs[h + 1]);
\r
520 p = contigs[h + 1] + contigs[h + 2];
\r
522 seqs[n] += fullseq.substring(p);
\r
534 * @return visible number of columns in alignment view
\r
536 public int getWidth()
\r
541 protected void setWidth(int width)
\r
543 this.width = width;
\r
547 * get the contiguous subalignments in an alignment view.
\r
549 * @param gapCharacter
\r
551 * @return SequenceI[][]
\r
553 public SequenceI[][] getVisibleContigs(char gapCharacter)
\r
555 SequenceI[][] smsa;
\r
557 if (sequences == null || width <= 0)
\r
561 if (contigs != null && contigs.length > 0)
\r
565 int fwidth = width;
\r
566 for (int contig = 0; contig < contigs.length; contig += 3)
\r
568 if ((contigs[contig + 1] - start) > 0)
\r
572 fwidth += contigs[contig + 2]; // end up with full region width
\r
573 // (including hidden regions)
\r
574 start = contigs[contig + 1] + contigs[contig + 2];
\r
576 if (start < fwidth)
\r
580 smsa = new SequenceI[njobs][];
\r
583 for (int contig = 0; contig < contigs.length; contig += 3)
\r
585 if (contigs[contig + 1] - start > 0)
\r
587 SequenceI mseq[] = new SequenceI[sequences.length];
\r
588 for (int s = 0; s < mseq.length; s++)
\r
590 mseq[s] = sequences[s].getSeq(gapCharacter).getSubSequence(
\r
591 start, contigs[contig + 1]);
\r
596 start = contigs[contig + 1] + contigs[contig + 2];
\r
598 if (start < fwidth)
\r
600 SequenceI mseq[] = new SequenceI[sequences.length];
\r
601 for (int s = 0; s < mseq.length; s++)
\r
603 mseq[s] = sequences[s].getSeq(gapCharacter).getSubSequence(start,
\r
612 smsa = new SequenceI[1][];
\r
613 smsa[0] = new SequenceI[sequences.length];
\r
614 for (int s = 0; s < sequences.length; s++)
\r
616 smsa[0][s] = sequences[s].getSeq(gapCharacter);
\r
623 * return full msa and hidden regions with visible blocks replaced with new
\r
629 * AlignmentOrder[] corresponding to each SequenceI[] block.
\r
632 public Object[] getUpdatedView(SequenceI[][] nvismsa,
\r
633 AlignmentOrder[] orders, char gapCharacter)
\r
635 if (sequences == null || width <= 0)
\r
637 throw new Error("empty view cannot be updated.");
\r
639 if (nvismsa == null)
\r
642 "nvismsa==null. use getAlignmentAndColumnSelection() instead.");
\r
644 if (contigs != null && contigs.length > 0)
\r
646 SequenceI[] alignment = new SequenceI[sequences.length];
\r
647 ColumnSelection columnselection = new ColumnSelection();
\r
648 if (contigs != null && contigs.length > 0)
\r
652 int owidth = width;
\r
654 for (int contig = 0; contig < contigs.length; contig += 3)
\r
656 owidth += contigs[contig + 2]; // recover final column width
\r
657 if (contigs[contig + 1] - start > 0)
\r
659 int swidth = 0; // subalignment width
\r
660 if (nvismsa[j] != null)
\r
662 SequenceI mseq[] = nvismsa[j];
\r
663 AlignmentOrder order = (orders == null) ? null : orders[j];
\r
665 if (mseq.length != sequences.length)
\r
668 "Mismatch between number of sequences in block "
\r
669 + j + " (" + mseq.length
\r
670 + ") and the original view ("
\r
671 + sequences.length + ")");
\r
673 swidth = mseq[0].getLength(); // JBPNote: could ensure padded
\r
675 for (int s = 0; s < mseq.length; s++)
\r
677 if (alignment[s] == null)
\r
679 alignment[s] = mseq[s];
\r
683 alignment[s].setSequence(alignment[s]
\r
684 .getSequenceAsString()
\r
685 + mseq[s].getSequenceAsString());
\r
686 if (mseq[s].getStart() <= mseq[s].getEnd())
\r
688 alignment[s].setEnd(mseq[s].getEnd());
\r
692 order.updateSequence(mseq[s], alignment[s]);
\r
699 // recover original alignment block or place gaps
\r
702 // recover input data
\r
703 for (int s = 0; s < sequences.length; s++)
\r
705 SequenceI oseq = sequences[s].getSeq(gapCharacter)
\r
706 .getSubSequence(start, contigs[contig + 1]);
\r
707 if (swidth < oseq.getLength())
\r
709 swidth = oseq.getLength();
\r
711 if (alignment[s] == null)
\r
713 alignment[s] = oseq;
\r
717 alignment[s].setSequence(alignment[s]
\r
718 .getSequenceAsString()
\r
719 + oseq.getSequenceAsString());
\r
720 if (oseq.getEnd() >= oseq.getStart())
\r
722 alignment[s].setEnd(oseq.getEnd());
\r
732 // advance to begining of visible region
\r
733 start = contigs[contig + 1] + contigs[contig + 2];
\r
734 // add hidden segment to right of next region
\r
735 for (int s = 0; s < sequences.length; s++)
\r
737 SequenceI hseq = sequences[s].getSeq(gapCharacter)
\r
738 .getSubSequence(contigs[contig + 1], start);
\r
739 if (alignment[s] == null)
\r
741 alignment[s] = hseq;
\r
745 alignment[s].setSequence(alignment[s].getSequenceAsString()
\r
746 + hseq.getSequenceAsString());
\r
747 if (hseq.getEnd() >= hseq.getStart())
\r
749 alignment[s].setEnd(hseq.getEnd());
\r
753 // mark hidden segment as hidden in the new alignment
\r
754 columnselection.hideColumns(nwidth, nwidth + contigs[contig + 2]
\r
756 nwidth += contigs[contig + 2];
\r
758 // Do final segment - if it exists
\r
759 if (j < nvismsa.length)
\r
762 if (nvismsa[j] != null)
\r
764 SequenceI mseq[] = nvismsa[j];
\r
765 AlignmentOrder order = (orders != null) ? orders[j] : null;
\r
766 swidth = mseq[0].getLength();
\r
767 for (int s = 0; s < mseq.length; s++)
\r
769 if (alignment[s] == null)
\r
771 alignment[s] = mseq[s];
\r
775 alignment[s].setSequence(alignment[s].getSequenceAsString()
\r
776 + mseq[s].getSequenceAsString());
\r
777 if (mseq[s].getEnd() >= mseq[s].getStart())
\r
779 alignment[s].setEnd(mseq[s].getEnd());
\r
783 order.updateSequence(mseq[s], alignment[s]);
\r
790 if (start < owidth)
\r
792 // recover input data or place gaps
\r
795 // recover input data
\r
796 for (int s = 0; s < sequences.length; s++)
\r
798 SequenceI oseq = sequences[s].getSeq(gapCharacter)
\r
799 .getSubSequence(start, owidth + 1);
\r
800 if (swidth < oseq.getLength())
\r
802 swidth = oseq.getLength();
\r
804 if (alignment[s] == null)
\r
806 alignment[s] = oseq;
\r
810 alignment[s].setSequence(alignment[s]
\r
811 .getSequenceAsString()
\r
812 + oseq.getSequenceAsString());
\r
813 if (oseq.getEnd() >= oseq.getStart())
\r
815 alignment[s].setEnd(oseq.getEnd());
\r
824 throw new Error("Padding not yet implemented.");
\r
830 return new Object[]
\r
831 { alignment, columnselection };
\r
835 if (nvismsa.length != 1)
\r
838 "Mismatch between visible blocks to update and number of contigs in view (contigs=0,blocks="
\r
841 if (nvismsa[0] != null)
\r
843 return new Object[]
\r
844 { nvismsa[0], new ColumnSelection() };
\r
848 return getAlignmentAndColumnSelection(gapCharacter);
\r
854 * returns simple array of start end positions of visible range on alignment.
\r
855 * vis_start and vis_end are inclusive - use
\r
856 * SequenceI.getSubSequence(vis_start, vis_end+1) to recover visible sequence
\r
857 * from underlying alignment.
\r
859 * @return int[] { start_i, end_i } for 1<i<n visible regions.
\r
861 public int[] getVisibleContigs()
\r
863 if (contigs != null && contigs.length > 0)
\r
867 int fwidth = width;
\r
868 for (int contig = 0; contig < contigs.length; contig += 3)
\r
870 if ((contigs[contig + 1] - start) > 0)
\r
874 fwidth += contigs[contig + 2]; // end up with full region width
\r
875 // (including hidden regions)
\r
876 start = contigs[contig + 1] + contigs[contig + 2];
\r
878 if (start < fwidth)
\r
882 int viscontigs[] = new int[nvis * 2];
\r
885 for (int contig = 0; contig < contigs.length; contig += 3)
\r
887 if ((contigs[contig + 1] - start) > 0)
\r
889 viscontigs[nvis] = start;
\r
890 viscontigs[nvis + 1] = contigs[contig + 1] - 1; // end is inclusive
\r
893 start = contigs[contig + 1] + contigs[contig + 2];
\r
895 if (start < fwidth)
\r
897 viscontigs[nvis] = start;
\r
898 viscontigs[nvis + 1] = fwidth; // end is inclusive
\r
912 * @return position of first visible column of AlignmentView within its
\r
913 * parent's alignment reference frame
\r
915 public int getAlignmentOrigin()
\r
921 * compute a deletion map for the current view according to the given
\r
925 * (as returned from SequenceI.gapMap())
\r
926 * @return int[] {intersection of visible regions with gapMap)
\r
928 public int[] getVisibleContigMapFor(int[] gapMap)
\r
930 int[] delMap = null;
\r
931 int[] viscontigs = getVisibleContigs();
\r
934 if (viscontigs != null)
\r
936 // viscontigs maps from a subset of the gapMap to the gapMap, so it will
\r
937 // always be equal to or shorter than gapMap
\r
938 delMap = new int[gapMap.length];
\r
939 for (int contig = 0; contig < viscontigs.length; contig += 2)
\r
942 while (spos < gapMap.length && gapMap[spos] < viscontigs[contig])
\r
946 while (spos < gapMap.length
\r
947 && gapMap[spos] <= viscontigs[contig + 1])
\r
949 delMap[i++] = spos++;
\r
952 int tmap[] = new int[i];
\r
953 System.arraycopy(delMap, 0, tmap, 0, i);
\r
960 * apply the getSeq(gc) method to each sequence cigar, and return the array of
\r
961 * edited sequences, optionally with hidden regions removed.
\r
964 * gap character to use for insertions
\r
966 * remove hidden regions from sequences. Note: currently implemented
\r
967 * in a memory inefficient way - space needed is 2*result set for
\r
970 * @return SequenceI[]
\r
972 public SequenceI[] getEditedSequences(char gc, boolean delete)
\r
974 SeqCigar[] msf = getSequences();
\r
975 SequenceI[] aln = new SequenceI[msf.length];
\r
976 for (int i = 0, j = msf.length; i < j; i++)
\r
978 aln[i] = msf[i].getSeq(gc);
\r
982 String[] sqs = getSequenceStrings(gc);
\r
983 for (int i = 0; i < sqs.length; i++)
\r
985 aln[i].setSequence(sqs[i]);
\r
992 public static void summariseAlignmentView(AlignmentView view,
\r
995 os.print("View has " + view.sequences.length + " of which ");
\r
996 if (view.selected == null) {
\r
999 os.print(" "+view.selected.size());
\r
1001 os.println(" are selected.");
\r
1002 os.print("View is " + view.getWidth() + " columns wide");
\r
1004 int[] contigs = view.getContigs();
\r
1005 if (contigs != null)
\r
1007 viswid = view.width;
\r
1008 for (int i = 0; i < contigs.length; i += 3)
\r
1010 viswid += contigs[i + 2];
\r
1012 os.println("with " + viswid + " visible columns spread over "
\r
1013 + contigs.length / 3 + " regions.");
\r
1017 viswid = view.width;
\r
1020 if (view.scGroups != null)
\r
1022 os.println("There are " + view.scGroups.size()
\r
1023 + " groups defined on the view.");
\r
1024 for (int g = 0; g < view.scGroups.size(); g++)
\r
1026 ScGroup sgr = (ScGroup) view.scGroups.elementAt(g);
\r
1027 os.println("Group " + g + ": Name = " + sgr.sg.getName()
\r
1028 + " Contains " + sgr.seqs.size() + " Seqs.");
\r
1029 os.println("This group runs from " + sgr.sg.getStartRes() + " to "
\r
1030 + sgr.sg.getEndRes());
\r
1031 for (int s = 0; s < sgr.seqs.size(); s++)
\r
1033 if (!((SeqCigar) sgr.seqs.elementAt(s)).isMemberOf(sgr))
\r
1035 os.println("** WARNING: sequence "
\r
1036 + ((SeqCigar) sgr.seqs.elementAt(s)).toString()
\r
1037 + " is not marked as member of group.");
\r
1041 AlignmentI visal = view.getVisibleAlignment('-');
\r
1042 if (visal != null)
\r
1044 os.println("Vis. alignment is " + visal.getWidth()
\r
1045 + " wide and has " + visal.getHeight() + " seqs.");
\r
1046 if (visal.getGroups() != null && visal.getGroups().size() > 0)
\r
1049 Enumeration en = visal.getGroups().elements();
\r
1051 while (en.hasMoreElements())
\r
1053 sg = (SequenceGroup) en.nextElement();
\r
1054 os.println("Group " + (i++) + " begins at column "
\r
1055 + sg.getStartRes() + " and ends at " + sg.getEndRes());
\r
1062 public static void testSelectionViews(AlignmentI alignment,
\r
1063 ColumnSelection csel, SequenceGroup selection)
\r
1065 System.out.println("Testing standard view creation:\n");
\r
1066 AlignmentView view = null;
\r
1070 .println("View with no hidden columns, no limit to selection, no groups to be collected:");
\r
1071 view = new AlignmentView(alignment, csel, selection, false, false,
\r
1073 summariseAlignmentView(view, System.out);
\r
1075 } catch (Exception e)
\r
1077 e.printStackTrace();
\r
1079 .println("Failed to generate alignment with selection but no groups marked.");
\r
1084 .println("View with no hidden columns, no limit to selection, and all groups to be collected:");
\r
1085 view = new AlignmentView(alignment, csel, selection, false, false,
\r
1087 summariseAlignmentView(view, System.out);
\r
1088 } catch (Exception e)
\r
1090 e.printStackTrace();
\r
1092 .println("Failed to generate alignment with selection marked but no groups marked.");
\r
1097 .println("View with no hidden columns, limited to selection and no groups to be collected:");
\r
1098 view = new AlignmentView(alignment, csel, selection, false, true,
\r
1100 summariseAlignmentView(view, System.out);
\r
1101 } catch (Exception e)
\r
1103 e.printStackTrace();
\r
1105 .println("Failed to generate alignment with selection restricted but no groups marked.");
\r
1110 .println("View with no hidden columns, limited to selection, and all groups to be collected:");
\r
1111 view = new AlignmentView(alignment, csel, selection, false, true,
\r
1113 summariseAlignmentView(view, System.out);
\r
1114 } catch (Exception e)
\r
1116 e.printStackTrace();
\r
1118 .println("Failed to generate alignment with selection restricted and groups marked.");
\r
1123 .println("View *with* hidden columns, no limit to selection, no groups to be collected:");
\r
1124 view = new AlignmentView(alignment, csel, selection, true, false,
\r
1126 summariseAlignmentView(view, System.out);
\r
1127 } catch (Exception e)
\r
1129 e.printStackTrace();
\r
1131 .println("Failed to generate alignment with selection but no groups marked.");
\r
1136 .println("View *with* hidden columns, no limit to selection, and all groups to be collected:");
\r
1137 view = new AlignmentView(alignment, csel, selection, true, false,
\r
1139 summariseAlignmentView(view, System.out);
\r
1140 } catch (Exception e)
\r
1142 e.printStackTrace();
\r
1144 .println("Failed to generate alignment with selection marked but no groups marked.");
\r
1149 .println("View *with* hidden columns, limited to selection and no groups to be collected:");
\r
1150 view = new AlignmentView(alignment, csel, selection, true, true,
\r
1152 summariseAlignmentView(view, System.out);
\r
1153 } catch (Exception e)
\r
1155 e.printStackTrace();
\r
1157 .println("Failed to generate alignment with selection restricted but no groups marked.");
\r
1162 .println("View *with* hidden columns, limited to selection, and all groups to be collected:");
\r
1163 view = new AlignmentView(alignment, csel, selection, true, true, true);
\r
1164 summariseAlignmentView(view, System.out);
\r
1165 } catch (Exception e)
\r
1167 e.printStackTrace();
\r
1169 .println("Failed to generate alignment with selection restricted and groups marked.");
\r